Audacious $Id:Doxyfile42802007-03-2104:39:00Znenolod$
dbus-server-bindings.h
Go to the documentation of this file.
00001 /* Generated by dbus-binding-tool; do not edit! */
00002 
00003 
00004 #ifndef __dbus_glib_marshal_audacious_rc_MARSHAL_H__
00005 #define __dbus_glib_marshal_audacious_rc_MARSHAL_H__
00006 
00007 #include        <glib-object.h>
00008 
00009 G_BEGIN_DECLS
00010 
00011 #ifdef G_ENABLE_DEBUG
00012 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
00013 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
00014 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
00015 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
00016 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
00017 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
00018 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
00019 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
00020 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
00021 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
00022 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
00023 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
00024 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
00025 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
00026 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
00027 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
00028 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
00029 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
00030 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
00031 #else /* !G_ENABLE_DEBUG */
00032 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
00033  *          Do not access GValues directly in your code. Instead, use the
00034  *          g_value_get_*() functions
00035  */
00036 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
00037 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
00038 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
00039 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
00040 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
00041 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
00042 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
00043 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
00044 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
00045 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
00046 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
00047 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
00048 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
00049 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
00050 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
00051 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
00052 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
00053 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
00054 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
00055 #endif /* !G_ENABLE_DEBUG */
00056 
00057 
00058 /* BOOLEAN:INT,POINTER */
00059 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER (GClosure     *closure,
00060                                                                  GValue       *return_value,
00061                                                                  guint         n_param_values,
00062                                                                  const GValue *param_values,
00063                                                                  gpointer      invocation_hint,
00064                                                                  gpointer      marshal_data);
00065 void
00066 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER (GClosure     *closure,
00067                                                      GValue       *return_value G_GNUC_UNUSED,
00068                                                      guint         n_param_values,
00069                                                      const GValue *param_values,
00070                                                      gpointer      invocation_hint G_GNUC_UNUSED,
00071                                                      gpointer      marshal_data)
00072 {
00073   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER) (gpointer     data1,
00074                                                          gint         arg_1,
00075                                                          gpointer     arg_2,
00076                                                          gpointer     data2);
00077   register GMarshalFunc_BOOLEAN__INT_POINTER callback;
00078   register GCClosure *cc = (GCClosure*) closure;
00079   register gpointer data1, data2;
00080   gboolean v_return;
00081 
00082   g_return_if_fail (return_value != NULL);
00083   g_return_if_fail (n_param_values == 3);
00084 
00085   if (G_CCLOSURE_SWAP_DATA (closure))
00086     {
00087       data1 = closure->data;
00088       data2 = g_value_peek_pointer (param_values + 0);
00089     }
00090   else
00091     {
00092       data1 = g_value_peek_pointer (param_values + 0);
00093       data2 = closure->data;
00094     }
00095   callback = (GMarshalFunc_BOOLEAN__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00096 
00097   v_return = callback (data1,
00098                        g_marshal_value_peek_int (param_values + 1),
00099                        g_marshal_value_peek_pointer (param_values + 2),
00100                        data2);
00101 
00102   g_value_set_boolean (return_value, v_return);
00103 }
00104 
00105 /* BOOLEAN:INT,DOUBLE,POINTER */
00106 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER (GClosure     *closure,
00107                                                                         GValue       *return_value,
00108                                                                         guint         n_param_values,
00109                                                                         const GValue *param_values,
00110                                                                         gpointer      invocation_hint,
00111                                                                         gpointer      marshal_data);
00112 void
00113 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER (GClosure     *closure,
00114                                                             GValue       *return_value G_GNUC_UNUSED,
00115                                                             guint         n_param_values,
00116                                                             const GValue *param_values,
00117                                                             gpointer      invocation_hint G_GNUC_UNUSED,
00118                                                             gpointer      marshal_data)
00119 {
00120   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER) (gpointer     data1,
00121                                                                 gint         arg_1,
00122                                                                 gdouble      arg_2,
00123                                                                 gpointer     arg_3,
00124                                                                 gpointer     data2);
00125   register GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER callback;
00126   register GCClosure *cc = (GCClosure*) closure;
00127   register gpointer data1, data2;
00128   gboolean v_return;
00129 
00130   g_return_if_fail (return_value != NULL);
00131   g_return_if_fail (n_param_values == 4);
00132 
00133   if (G_CCLOSURE_SWAP_DATA (closure))
00134     {
00135       data1 = closure->data;
00136       data2 = g_value_peek_pointer (param_values + 0);
00137     }
00138   else
00139     {
00140       data1 = g_value_peek_pointer (param_values + 0);
00141       data2 = closure->data;
00142     }
00143   callback = (GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
00144 
00145   v_return = callback (data1,
00146                        g_marshal_value_peek_int (param_values + 1),
00147                        g_marshal_value_peek_double (param_values + 2),
00148                        g_marshal_value_peek_pointer (param_values + 3),
00149                        data2);
00150 
00151   g_value_set_boolean (return_value, v_return);
00152 }
00153 
00154 /* BOOLEAN:INT,INT,POINTER */
00155 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER (GClosure     *closure,
00156                                                                      GValue       *return_value,
00157                                                                      guint         n_param_values,
00158                                                                      const GValue *param_values,
00159                                                                      gpointer      invocation_hint,
00160                                                                      gpointer      marshal_data);
00161 void
00162 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER (GClosure     *closure,
00163                                                          GValue       *return_value G_GNUC_UNUSED,
00164                                                          guint         n_param_values,
00165                                                          const GValue *param_values,
00166                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00167                                                          gpointer      marshal_data)
00168 {
00169   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_POINTER) (gpointer     data1,
00170                                                              gint         arg_1,
00171                                                              gint         arg_2,
00172                                                              gpointer     arg_3,
00173                                                              gpointer     data2);
00174   register GMarshalFunc_BOOLEAN__INT_INT_POINTER callback;
00175   register GCClosure *cc = (GCClosure*) closure;
00176   register gpointer data1, data2;
00177   gboolean v_return;
00178 
00179   g_return_if_fail (return_value != NULL);
00180   g_return_if_fail (n_param_values == 4);
00181 
00182   if (G_CCLOSURE_SWAP_DATA (closure))
00183     {
00184       data1 = closure->data;
00185       data2 = g_value_peek_pointer (param_values + 0);
00186     }
00187   else
00188     {
00189       data1 = g_value_peek_pointer (param_values + 0);
00190       data2 = closure->data;
00191     }
00192   callback = (GMarshalFunc_BOOLEAN__INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00193 
00194   v_return = callback (data1,
00195                        g_marshal_value_peek_int (param_values + 1),
00196                        g_marshal_value_peek_int (param_values + 2),
00197                        g_marshal_value_peek_pointer (param_values + 3),
00198                        data2);
00199 
00200   g_value_set_boolean (return_value, v_return);
00201 }
00202 
00203 /* BOOLEAN:POINTER,POINTER,POINTER,POINTER */
00204 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER (GClosure     *closure,
00205                                                                                      GValue       *return_value,
00206                                                                                      guint         n_param_values,
00207                                                                                      const GValue *param_values,
00208                                                                                      gpointer      invocation_hint,
00209                                                                                      gpointer      marshal_data);
00210 void
00211 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER (GClosure     *closure,
00212                                                                          GValue       *return_value G_GNUC_UNUSED,
00213                                                                          guint         n_param_values,
00214                                                                          const GValue *param_values,
00215                                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00216                                                                          gpointer      marshal_data)
00217 {
00218   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER) (gpointer     data1,
00219                                                                              gpointer     arg_1,
00220                                                                              gpointer     arg_2,
00221                                                                              gpointer     arg_3,
00222                                                                              gpointer     arg_4,
00223                                                                              gpointer     data2);
00224   register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER callback;
00225   register GCClosure *cc = (GCClosure*) closure;
00226   register gpointer data1, data2;
00227   gboolean v_return;
00228 
00229   g_return_if_fail (return_value != NULL);
00230   g_return_if_fail (n_param_values == 5);
00231 
00232   if (G_CCLOSURE_SWAP_DATA (closure))
00233     {
00234       data1 = closure->data;
00235       data2 = g_value_peek_pointer (param_values + 0);
00236     }
00237   else
00238     {
00239       data1 = g_value_peek_pointer (param_values + 0);
00240       data2 = closure->data;
00241     }
00242   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00243 
00244   v_return = callback (data1,
00245                        g_marshal_value_peek_pointer (param_values + 1),
00246                        g_marshal_value_peek_pointer (param_values + 2),
00247                        g_marshal_value_peek_pointer (param_values + 3),
00248                        g_marshal_value_peek_pointer (param_values + 4),
00249                        data2);
00250 
00251   g_value_set_boolean (return_value, v_return);
00252 }
00253 
00254 /* BOOLEAN:INT,POINTER,POINTER */
00255 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
00256                                                                          GValue       *return_value,
00257                                                                          guint         n_param_values,
00258                                                                          const GValue *param_values,
00259                                                                          gpointer      invocation_hint,
00260                                                                          gpointer      marshal_data);
00261 void
00262 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
00263                                                              GValue       *return_value G_GNUC_UNUSED,
00264                                                              guint         n_param_values,
00265                                                              const GValue *param_values,
00266                                                              gpointer      invocation_hint G_GNUC_UNUSED,
00267                                                              gpointer      marshal_data)
00268 {
00269   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (gpointer     data1,
00270                                                                  gint         arg_1,
00271                                                                  gpointer     arg_2,
00272                                                                  gpointer     arg_3,
00273                                                                  gpointer     data2);
00274   register GMarshalFunc_BOOLEAN__INT_POINTER_POINTER callback;
00275   register GCClosure *cc = (GCClosure*) closure;
00276   register gpointer data1, data2;
00277   gboolean v_return;
00278 
00279   g_return_if_fail (return_value != NULL);
00280   g_return_if_fail (n_param_values == 4);
00281 
00282   if (G_CCLOSURE_SWAP_DATA (closure))
00283     {
00284       data1 = closure->data;
00285       data2 = g_value_peek_pointer (param_values + 0);
00286     }
00287   else
00288     {
00289       data1 = g_value_peek_pointer (param_values + 0);
00290       data2 = closure->data;
00291     }
00292   callback = (GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00293 
00294   v_return = callback (data1,
00295                        g_marshal_value_peek_int (param_values + 1),
00296                        g_marshal_value_peek_pointer (param_values + 2),
00297                        g_marshal_value_peek_pointer (param_values + 3),
00298                        data2);
00299 
00300   g_value_set_boolean (return_value, v_return);
00301 }
00302 
00303 /* BOOLEAN:POINTER */
00304 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER (GClosure     *closure,
00305                                                              GValue       *return_value,
00306                                                              guint         n_param_values,
00307                                                              const GValue *param_values,
00308                                                              gpointer      invocation_hint,
00309                                                              gpointer      marshal_data);
00310 void
00311 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER (GClosure     *closure,
00312                                                  GValue       *return_value G_GNUC_UNUSED,
00313                                                  guint         n_param_values,
00314                                                  const GValue *param_values,
00315                                                  gpointer      invocation_hint G_GNUC_UNUSED,
00316                                                  gpointer      marshal_data)
00317 {
00318   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
00319                                                      gpointer     arg_1,
00320                                                      gpointer     data2);
00321   register GMarshalFunc_BOOLEAN__POINTER callback;
00322   register GCClosure *cc = (GCClosure*) closure;
00323   register gpointer data1, data2;
00324   gboolean v_return;
00325 
00326   g_return_if_fail (return_value != NULL);
00327   g_return_if_fail (n_param_values == 2);
00328 
00329   if (G_CCLOSURE_SWAP_DATA (closure))
00330     {
00331       data1 = closure->data;
00332       data2 = g_value_peek_pointer (param_values + 0);
00333     }
00334   else
00335     {
00336       data1 = g_value_peek_pointer (param_values + 0);
00337       data2 = closure->data;
00338     }
00339   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
00340 
00341   v_return = callback (data1,
00342                        g_marshal_value_peek_pointer (param_values + 1),
00343                        data2);
00344 
00345   g_value_set_boolean (return_value, v_return);
00346 }
00347 
00348 /* BOOLEAN:POINTER,POINTER */
00349 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER (GClosure     *closure,
00350                                                                      GValue       *return_value,
00351                                                                      guint         n_param_values,
00352                                                                      const GValue *param_values,
00353                                                                      gpointer      invocation_hint,
00354                                                                      gpointer      marshal_data);
00355 void
00356 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER (GClosure     *closure,
00357                                                          GValue       *return_value G_GNUC_UNUSED,
00358                                                          guint         n_param_values,
00359                                                          const GValue *param_values,
00360                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00361                                                          gpointer      marshal_data)
00362 {
00363   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
00364                                                              gpointer     arg_1,
00365                                                              gpointer     arg_2,
00366                                                              gpointer     data2);
00367   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
00368   register GCClosure *cc = (GCClosure*) closure;
00369   register gpointer data1, data2;
00370   gboolean v_return;
00371 
00372   g_return_if_fail (return_value != NULL);
00373   g_return_if_fail (n_param_values == 3);
00374 
00375   if (G_CCLOSURE_SWAP_DATA (closure))
00376     {
00377       data1 = closure->data;
00378       data2 = g_value_peek_pointer (param_values + 0);
00379     }
00380   else
00381     {
00382       data1 = g_value_peek_pointer (param_values + 0);
00383       data2 = closure->data;
00384     }
00385   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00386 
00387   v_return = callback (data1,
00388                        g_marshal_value_peek_pointer (param_values + 1),
00389                        g_marshal_value_peek_pointer (param_values + 2),
00390                        data2);
00391 
00392   g_value_set_boolean (return_value, v_return);
00393 }
00394 
00395 /* BOOLEAN:DOUBLE,POINTER */
00396 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
00397                                                                     GValue       *return_value,
00398                                                                     guint         n_param_values,
00399                                                                     const GValue *param_values,
00400                                                                     gpointer      invocation_hint,
00401                                                                     gpointer      marshal_data);
00402 void
00403 dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_POINTER (GClosure     *closure,
00404                                                         GValue       *return_value G_GNUC_UNUSED,
00405                                                         guint         n_param_values,
00406                                                         const GValue *param_values,
00407                                                         gpointer      invocation_hint G_GNUC_UNUSED,
00408                                                         gpointer      marshal_data)
00409 {
00410   typedef gboolean (*GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (gpointer     data1,
00411                                                             gdouble      arg_1,
00412                                                             gpointer     arg_2,
00413                                                             gpointer     data2);
00414   register GMarshalFunc_BOOLEAN__DOUBLE_POINTER callback;
00415   register GCClosure *cc = (GCClosure*) closure;
00416   register gpointer data1, data2;
00417   gboolean v_return;
00418 
00419   g_return_if_fail (return_value != NULL);
00420   g_return_if_fail (n_param_values == 3);
00421 
00422   if (G_CCLOSURE_SWAP_DATA (closure))
00423     {
00424       data1 = closure->data;
00425       data2 = g_value_peek_pointer (param_values + 0);
00426     }
00427   else
00428     {
00429       data1 = g_value_peek_pointer (param_values + 0);
00430       data2 = closure->data;
00431     }
00432   callback = (GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
00433 
00434   v_return = callback (data1,
00435                        g_marshal_value_peek_double (param_values + 1),
00436                        g_marshal_value_peek_pointer (param_values + 2),
00437                        data2);
00438 
00439   g_value_set_boolean (return_value, v_return);
00440 }
00441 
00442 /* BOOLEAN:BOXED,POINTER */
00443 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER (GClosure     *closure,
00444                                                                    GValue       *return_value,
00445                                                                    guint         n_param_values,
00446                                                                    const GValue *param_values,
00447                                                                    gpointer      invocation_hint,
00448                                                                    gpointer      marshal_data);
00449 void
00450 dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER (GClosure     *closure,
00451                                                        GValue       *return_value G_GNUC_UNUSED,
00452                                                        guint         n_param_values,
00453                                                        const GValue *param_values,
00454                                                        gpointer      invocation_hint G_GNUC_UNUSED,
00455                                                        gpointer      marshal_data)
00456 {
00457   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_POINTER) (gpointer     data1,
00458                                                            gpointer     arg_1,
00459                                                            gpointer     arg_2,
00460                                                            gpointer     data2);
00461   register GMarshalFunc_BOOLEAN__BOXED_POINTER callback;
00462   register GCClosure *cc = (GCClosure*) closure;
00463   register gpointer data1, data2;
00464   gboolean v_return;
00465 
00466   g_return_if_fail (return_value != NULL);
00467   g_return_if_fail (n_param_values == 3);
00468 
00469   if (G_CCLOSURE_SWAP_DATA (closure))
00470     {
00471       data1 = closure->data;
00472       data2 = g_value_peek_pointer (param_values + 0);
00473     }
00474   else
00475     {
00476       data1 = g_value_peek_pointer (param_values + 0);
00477       data2 = closure->data;
00478     }
00479   callback = (GMarshalFunc_BOOLEAN__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
00480 
00481   v_return = callback (data1,
00482                        g_marshal_value_peek_boxed (param_values + 1),
00483                        g_marshal_value_peek_pointer (param_values + 2),
00484                        data2);
00485 
00486   g_value_set_boolean (return_value, v_return);
00487 }
00488 
00489 /* BOOLEAN:POINTER,POINTER,POINTER */
00490 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER (GClosure     *closure,
00491                                                                              GValue       *return_value,
00492                                                                              guint         n_param_values,
00493                                                                              const GValue *param_values,
00494                                                                              gpointer      invocation_hint,
00495                                                                              gpointer      marshal_data);
00496 void
00497 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER (GClosure     *closure,
00498                                                                  GValue       *return_value G_GNUC_UNUSED,
00499                                                                  guint         n_param_values,
00500                                                                  const GValue *param_values,
00501                                                                  gpointer      invocation_hint G_GNUC_UNUSED,
00502                                                                  gpointer      marshal_data)
00503 {
00504   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (gpointer     data1,
00505                                                                      gpointer     arg_1,
00506                                                                      gpointer     arg_2,
00507                                                                      gpointer     arg_3,
00508                                                                      gpointer     data2);
00509   register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER callback;
00510   register GCClosure *cc = (GCClosure*) closure;
00511   register gpointer data1, data2;
00512   gboolean v_return;
00513 
00514   g_return_if_fail (return_value != NULL);
00515   g_return_if_fail (n_param_values == 4);
00516 
00517   if (G_CCLOSURE_SWAP_DATA (closure))
00518     {
00519       data1 = closure->data;
00520       data2 = g_value_peek_pointer (param_values + 0);
00521     }
00522   else
00523     {
00524       data1 = g_value_peek_pointer (param_values + 0);
00525       data2 = closure->data;
00526     }
00527   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00528 
00529   v_return = callback (data1,
00530                        g_marshal_value_peek_pointer (param_values + 1),
00531                        g_marshal_value_peek_pointer (param_values + 2),
00532                        g_marshal_value_peek_pointer (param_values + 3),
00533                        data2);
00534 
00535   g_value_set_boolean (return_value, v_return);
00536 }
00537 
00538 /* BOOLEAN:DOUBLE,BOXED,POINTER */
00539 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_BOXED_POINTER (GClosure     *closure,
00540                                                                           GValue       *return_value,
00541                                                                           guint         n_param_values,
00542                                                                           const GValue *param_values,
00543                                                                           gpointer      invocation_hint,
00544                                                                           gpointer      marshal_data);
00545 void
00546 dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_BOXED_POINTER (GClosure     *closure,
00547                                                               GValue       *return_value G_GNUC_UNUSED,
00548                                                               guint         n_param_values,
00549                                                               const GValue *param_values,
00550                                                               gpointer      invocation_hint G_GNUC_UNUSED,
00551                                                               gpointer      marshal_data)
00552 {
00553   typedef gboolean (*GMarshalFunc_BOOLEAN__DOUBLE_BOXED_POINTER) (gpointer     data1,
00554                                                                   gdouble      arg_1,
00555                                                                   gpointer     arg_2,
00556                                                                   gpointer     arg_3,
00557                                                                   gpointer     data2);
00558   register GMarshalFunc_BOOLEAN__DOUBLE_BOXED_POINTER callback;
00559   register GCClosure *cc = (GCClosure*) closure;
00560   register gpointer data1, data2;
00561   gboolean v_return;
00562 
00563   g_return_if_fail (return_value != NULL);
00564   g_return_if_fail (n_param_values == 4);
00565 
00566   if (G_CCLOSURE_SWAP_DATA (closure))
00567     {
00568       data1 = closure->data;
00569       data2 = g_value_peek_pointer (param_values + 0);
00570     }
00571   else
00572     {
00573       data1 = g_value_peek_pointer (param_values + 0);
00574       data2 = closure->data;
00575     }
00576   callback = (GMarshalFunc_BOOLEAN__DOUBLE_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
00577 
00578   v_return = callback (data1,
00579                        g_marshal_value_peek_double (param_values + 1),
00580                        g_marshal_value_peek_boxed (param_values + 2),
00581                        g_marshal_value_peek_pointer (param_values + 3),
00582                        data2);
00583 
00584   g_value_set_boolean (return_value, v_return);
00585 }
00586 
00587 /* BOOLEAN:STRING,INT,POINTER */
00588 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER (GClosure     *closure,
00589                                                                         GValue       *return_value,
00590                                                                         guint         n_param_values,
00591                                                                         const GValue *param_values,
00592                                                                         gpointer      invocation_hint,
00593                                                                         gpointer      marshal_data);
00594 void
00595 dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER (GClosure     *closure,
00596                                                             GValue       *return_value G_GNUC_UNUSED,
00597                                                             guint         n_param_values,
00598                                                             const GValue *param_values,
00599                                                             gpointer      invocation_hint G_GNUC_UNUSED,
00600                                                             gpointer      marshal_data)
00601 {
00602   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_INT_POINTER) (gpointer     data1,
00603                                                                 gpointer     arg_1,
00604                                                                 gint         arg_2,
00605                                                                 gpointer     arg_3,
00606                                                                 gpointer     data2);
00607   register GMarshalFunc_BOOLEAN__STRING_INT_POINTER callback;
00608   register GCClosure *cc = (GCClosure*) closure;
00609   register gpointer data1, data2;
00610   gboolean v_return;
00611 
00612   g_return_if_fail (return_value != NULL);
00613   g_return_if_fail (n_param_values == 4);
00614 
00615   if (G_CCLOSURE_SWAP_DATA (closure))
00616     {
00617       data1 = closure->data;
00618       data2 = g_value_peek_pointer (param_values + 0);
00619     }
00620   else
00621     {
00622       data1 = g_value_peek_pointer (param_values + 0);
00623       data2 = closure->data;
00624     }
00625   callback = (GMarshalFunc_BOOLEAN__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00626 
00627   v_return = callback (data1,
00628                        g_marshal_value_peek_string (param_values + 1),
00629                        g_marshal_value_peek_int (param_values + 2),
00630                        g_marshal_value_peek_pointer (param_values + 3),
00631                        data2);
00632 
00633   g_value_set_boolean (return_value, v_return);
00634 }
00635 
00636 /* BOOLEAN:UINT,POINTER */
00637 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER (GClosure     *closure,
00638                                                                   GValue       *return_value,
00639                                                                   guint         n_param_values,
00640                                                                   const GValue *param_values,
00641                                                                   gpointer      invocation_hint,
00642                                                                   gpointer      marshal_data);
00643 void
00644 dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER (GClosure     *closure,
00645                                                       GValue       *return_value G_GNUC_UNUSED,
00646                                                       guint         n_param_values,
00647                                                       const GValue *param_values,
00648                                                       gpointer      invocation_hint G_GNUC_UNUSED,
00649                                                       gpointer      marshal_data)
00650 {
00651   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_POINTER) (gpointer     data1,
00652                                                           guint        arg_1,
00653                                                           gpointer     arg_2,
00654                                                           gpointer     data2);
00655   register GMarshalFunc_BOOLEAN__UINT_POINTER callback;
00656   register GCClosure *cc = (GCClosure*) closure;
00657   register gpointer data1, data2;
00658   gboolean v_return;
00659 
00660   g_return_if_fail (return_value != NULL);
00661   g_return_if_fail (n_param_values == 3);
00662 
00663   if (G_CCLOSURE_SWAP_DATA (closure))
00664     {
00665       data1 = closure->data;
00666       data2 = g_value_peek_pointer (param_values + 0);
00667     }
00668   else
00669     {
00670       data1 = g_value_peek_pointer (param_values + 0);
00671       data2 = closure->data;
00672     }
00673   callback = (GMarshalFunc_BOOLEAN__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
00674 
00675   v_return = callback (data1,
00676                        g_marshal_value_peek_uint (param_values + 1),
00677                        g_marshal_value_peek_pointer (param_values + 2),
00678                        data2);
00679 
00680   g_value_set_boolean (return_value, v_return);
00681 }
00682 
00683 /* BOOLEAN:UINT,STRING,POINTER,POINTER */
00684 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_STRING_POINTER_POINTER (GClosure     *closure,
00685                                                                                  GValue       *return_value,
00686                                                                                  guint         n_param_values,
00687                                                                                  const GValue *param_values,
00688                                                                                  gpointer      invocation_hint,
00689                                                                                  gpointer      marshal_data);
00690 void
00691 dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_STRING_POINTER_POINTER (GClosure     *closure,
00692                                                                      GValue       *return_value G_GNUC_UNUSED,
00693                                                                      guint         n_param_values,
00694                                                                      const GValue *param_values,
00695                                                                      gpointer      invocation_hint G_GNUC_UNUSED,
00696                                                                      gpointer      marshal_data)
00697 {
00698   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_STRING_POINTER_POINTER) (gpointer     data1,
00699                                                                          guint        arg_1,
00700                                                                          gpointer     arg_2,
00701                                                                          gpointer     arg_3,
00702                                                                          gpointer     arg_4,
00703                                                                          gpointer     data2);
00704   register GMarshalFunc_BOOLEAN__UINT_STRING_POINTER_POINTER callback;
00705   register GCClosure *cc = (GCClosure*) closure;
00706   register gpointer data1, data2;
00707   gboolean v_return;
00708 
00709   g_return_if_fail (return_value != NULL);
00710   g_return_if_fail (n_param_values == 5);
00711 
00712   if (G_CCLOSURE_SWAP_DATA (closure))
00713     {
00714       data1 = closure->data;
00715       data2 = g_value_peek_pointer (param_values + 0);
00716     }
00717   else
00718     {
00719       data1 = g_value_peek_pointer (param_values + 0);
00720       data2 = closure->data;
00721     }
00722   callback = (GMarshalFunc_BOOLEAN__UINT_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00723 
00724   v_return = callback (data1,
00725                        g_marshal_value_peek_uint (param_values + 1),
00726                        g_marshal_value_peek_string (param_values + 2),
00727                        g_marshal_value_peek_pointer (param_values + 3),
00728                        g_marshal_value_peek_pointer (param_values + 4),
00729                        data2);
00730 
00731   g_value_set_boolean (return_value, v_return);
00732 }
00733 
00734 /* BOOLEAN:STRING,POINTER */
00735 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER (GClosure     *closure,
00736                                                                     GValue       *return_value,
00737                                                                     guint         n_param_values,
00738                                                                     const GValue *param_values,
00739                                                                     gpointer      invocation_hint,
00740                                                                     gpointer      marshal_data);
00741 void
00742 dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER (GClosure     *closure,
00743                                                         GValue       *return_value G_GNUC_UNUSED,
00744                                                         guint         n_param_values,
00745                                                         const GValue *param_values,
00746                                                         gpointer      invocation_hint G_GNUC_UNUSED,
00747                                                         gpointer      marshal_data)
00748 {
00749   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_POINTER) (gpointer     data1,
00750                                                             gpointer     arg_1,
00751                                                             gpointer     arg_2,
00752                                                             gpointer     data2);
00753   register GMarshalFunc_BOOLEAN__STRING_POINTER callback;
00754   register GCClosure *cc = (GCClosure*) closure;
00755   register gpointer data1, data2;
00756   gboolean v_return;
00757 
00758   g_return_if_fail (return_value != NULL);
00759   g_return_if_fail (n_param_values == 3);
00760 
00761   if (G_CCLOSURE_SWAP_DATA (closure))
00762     {
00763       data1 = closure->data;
00764       data2 = g_value_peek_pointer (param_values + 0);
00765     }
00766   else
00767     {
00768       data1 = g_value_peek_pointer (param_values + 0);
00769       data2 = closure->data;
00770     }
00771   callback = (GMarshalFunc_BOOLEAN__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
00772 
00773   v_return = callback (data1,
00774                        g_marshal_value_peek_string (param_values + 1),
00775                        g_marshal_value_peek_pointer (param_values + 2),
00776                        data2);
00777 
00778   g_value_set_boolean (return_value, v_return);
00779 }
00780 
00781 /* BOOLEAN:UINT,POINTER,POINTER */
00782 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER (GClosure     *closure,
00783                                                                           GValue       *return_value,
00784                                                                           guint         n_param_values,
00785                                                                           const GValue *param_values,
00786                                                                           gpointer      invocation_hint,
00787                                                                           gpointer      marshal_data);
00788 void
00789 dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER (GClosure     *closure,
00790                                                               GValue       *return_value G_GNUC_UNUSED,
00791                                                               guint         n_param_values,
00792                                                               const GValue *param_values,
00793                                                               gpointer      invocation_hint G_GNUC_UNUSED,
00794                                                               gpointer      marshal_data)
00795 {
00796   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_POINTER_POINTER) (gpointer     data1,
00797                                                                   guint        arg_1,
00798                                                                   gpointer     arg_2,
00799                                                                   gpointer     arg_3,
00800                                                                   gpointer     data2);
00801   register GMarshalFunc_BOOLEAN__UINT_POINTER_POINTER callback;
00802   register GCClosure *cc = (GCClosure*) closure;
00803   register gpointer data1, data2;
00804   gboolean v_return;
00805 
00806   g_return_if_fail (return_value != NULL);
00807   g_return_if_fail (n_param_values == 4);
00808 
00809   if (G_CCLOSURE_SWAP_DATA (closure))
00810     {
00811       data1 = closure->data;
00812       data2 = g_value_peek_pointer (param_values + 0);
00813     }
00814   else
00815     {
00816       data1 = g_value_peek_pointer (param_values + 0);
00817       data2 = closure->data;
00818     }
00819   callback = (GMarshalFunc_BOOLEAN__UINT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00820 
00821   v_return = callback (data1,
00822                        g_marshal_value_peek_uint (param_values + 1),
00823                        g_marshal_value_peek_pointer (param_values + 2),
00824                        g_marshal_value_peek_pointer (param_values + 3),
00825                        data2);
00826 
00827   g_value_set_boolean (return_value, v_return);
00828 }
00829 
00830 /* BOOLEAN:BOOLEAN,POINTER */
00831 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
00832                                                                      GValue       *return_value,
00833                                                                      guint         n_param_values,
00834                                                                      const GValue *param_values,
00835                                                                      gpointer      invocation_hint,
00836                                                                      gpointer      marshal_data);
00837 void
00838 dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
00839                                                          GValue       *return_value G_GNUC_UNUSED,
00840                                                          guint         n_param_values,
00841                                                          const GValue *param_values,
00842                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00843                                                          gpointer      marshal_data)
00844 {
00845   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
00846                                                              gboolean     arg_1,
00847                                                              gpointer     arg_2,
00848                                                              gpointer     data2);
00849   register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
00850   register GCClosure *cc = (GCClosure*) closure;
00851   register gpointer data1, data2;
00852   gboolean v_return;
00853 
00854   g_return_if_fail (return_value != NULL);
00855   g_return_if_fail (n_param_values == 3);
00856 
00857   if (G_CCLOSURE_SWAP_DATA (closure))
00858     {
00859       data1 = closure->data;
00860       data2 = g_value_peek_pointer (param_values + 0);
00861     }
00862   else
00863     {
00864       data1 = g_value_peek_pointer (param_values + 0);
00865       data2 = closure->data;
00866     }
00867   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
00868 
00869   v_return = callback (data1,
00870                        g_marshal_value_peek_boolean (param_values + 1),
00871                        g_marshal_value_peek_pointer (param_values + 2),
00872                        data2);
00873 
00874   g_value_set_boolean (return_value, v_return);
00875 }
00876 
00877 G_END_DECLS
00878 
00879 #endif /* __dbus_glib_marshal_audacious_rc_MARSHAL_H__ */
00880 
00881 #include <dbus/dbus-glib.h>
00882 static const DBusGMethodInfo dbus_glib_audacious_rc_methods[] = {
00883   { (GCallback) audacious_rc_version, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 0 },
00884   { (GCallback) audacious_rc_quit, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 48 },
00885   { (GCallback) audacious_rc_eject, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 77 },
00886   { (GCallback) audacious_rc_main_win_visible, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 107 },
00887   { (GCallback) audacious_rc_show_main_win, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 166 },
00888   { (GCallback) audacious_rc_get_tuple_fields, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 211 },
00889   { (GCallback) audacious_rc_play, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 266 },
00890   { (GCallback) audacious_rc_pause, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 295 },
00891   { (GCallback) audacious_rc_stop, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 325 },
00892   { (GCallback) audacious_rc_playing, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 354 },
00893   { (GCallback) audacious_rc_paused, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 405 },
00894   { (GCallback) audacious_rc_stopped, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 454 },
00895   { (GCallback) audacious_rc_status, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 505 },
00896   { (GCallback) audacious_rc_info, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER, 551 },
00897   { (GCallback) audacious_rc_time, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 618 },
00898   { (GCallback) audacious_rc_seek, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 660 },
00899   { (GCallback) audacious_rc_volume, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER, 697 },
00900   { (GCallback) audacious_rc_set_volume, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER, 750 },
00901   { (GCallback) audacious_rc_balance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 798 },
00902   { (GCallback) audacious_rc_position, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 846 },
00903   { (GCallback) audacious_rc_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 891 },
00904   { (GCallback) audacious_rc_reverse, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 923 },
00905   { (GCallback) audacious_rc_length, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 955 },
00906   { (GCallback) audacious_rc_song_title, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1001 },
00907   { (GCallback) audacious_rc_song_filename, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1057 },
00908   { (GCallback) audacious_rc_song_length, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1119 },
00909   { (GCallback) audacious_rc_song_frames, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1177 },
00910   { (GCallback) audacious_rc_song_tuple, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_STRING_POINTER_POINTER, 1235 },
00911   { (GCallback) audacious_rc_jump, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 1301 },
00912   { (GCallback) audacious_rc_add, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 1338 },
00913   { (GCallback) audacious_rc_add_url, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 1375 },
00914   { (GCallback) audacious_rc_add_list, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1414 },
00915   { (GCallback) audacious_rc_open_list, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1461 },
00916   { (GCallback) audacious_rc_open_list_to_temp, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1509 },
00917   { (GCallback) audacious_rc_delete, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 1563 },
00918   { (GCallback) audacious_rc_clear, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1602 },
00919   { (GCallback) audacious_rc_auto_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1632 },
00920   { (GCallback) audacious_rc_toggle_auto_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1687 },
00921   { (GCallback) audacious_rc_repeat, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1729 },
00922   { (GCallback) audacious_rc_toggle_repeat, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1778 },
00923   { (GCallback) audacious_rc_shuffle, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1815 },
00924   { (GCallback) audacious_rc_toggle_shuffle, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1866 },
00925   { (GCallback) audacious_rc_show_prefs_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 1904 },
00926   { (GCallback) audacious_rc_show_about_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 1950 },
00927   { (GCallback) audacious_rc_show_jtf_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 1996 },
00928   { (GCallback) audacious_rc_show_filebrowser, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2040 },
00929   { (GCallback) audacious_rc_play_pause, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2089 },
00930   { (GCallback) audacious_rc_queue_get_list_pos, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 2123 },
00931   { (GCallback) audacious_rc_queue_get_queue_pos, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 2184 },
00932   { (GCallback) audacious_rc_get_info, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER, 2246 },
00933   { (GCallback) audacious_rc_toggle_aot, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2316 },
00934   { (GCallback) audacious_rc_get_playqueue_length, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 2360 },
00935   { (GCallback) audacious_rc_playlist_ins_url_string, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER, 2418 },
00936   { (GCallback) audacious_rc_playlist_add, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 2479 },
00937   { (GCallback) audacious_rc_playqueue_add, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER, 2524 },
00938   { (GCallback) audacious_rc_playqueue_remove, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER, 2569 },
00939   { (GCallback) audacious_rc_playqueue_clear, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2617 },
00940   { (GCallback) audacious_rc_playqueue_is_queued, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER, 2656 },
00941   { (GCallback) audacious_rc_playlist_enqueue_to_temp, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 2724 },
00942   { (GCallback) audacious_rc_get_eq, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER, 2778 },
00943   { (GCallback) audacious_rc_get_eq_preamp, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 2838 },
00944   { (GCallback) audacious_rc_get_eq_band, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER, 2889 },
00945   { (GCallback) audacious_rc_set_eq, dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_BOXED_POINTER, 2946 },
00946   { (GCallback) audacious_rc_set_eq_preamp, dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_POINTER, 2998 },
00947   { (GCallback) audacious_rc_set_eq_band, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER, 3045 },
00948   { (GCallback) audacious_rc_equalizer_activate, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 3098 },
00949   { (GCallback) audacious_rc_get_active_playlist_name, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 3151 },
00950 };
00951 
00952 const DBusGObjectInfo dbus_glib_audacious_rc_object_info = {  1,
00953   dbus_glib_audacious_rc_methods,
00954   67,
00955 "org.atheme.audacious\0Version\0S\0version\0O\0F\0N\0s\0\0org.atheme.audacious\0Quit\0S\0\0org.atheme.audacious\0Eject\0S\0\0org.atheme.audacious\0MainWinVisible\0S\0is_main_win\0O\0F\0N\0b\0\0org.atheme.audacious\0ShowMainWin\0S\0show\0I\0b\0\0org.atheme.audacious\0GetTupleFields\0S\0fields\0O\0F\0N\0as\0\0org.atheme.audacious\0Play\0S\0\0org.atheme.audacious\0Pause\0S\0\0org.atheme.audacious\0Stop\0S\0\0org.atheme.audacious\0Playing\0S\0is_playing\0O\0F\0N\0b\0\0org.atheme.audacious\0Paused\0S\0is_paused\0O\0F\0N\0b\0\0org.atheme.audacious\0Stopped\0S\0is_stopped\0O\0F\0N\0b\0\0org.atheme.audacious\0Status\0S\0status\0O\0F\0N\0s\0\0org.atheme.audacious\0Info\0S\0rate\0O\0F\0N\0i\0freq\0O\0F\0N\0i\0nch\0O\0F\0N\0i\0\0org.atheme.audacious\0Time\0S\0time\0O\0F\0N\0u\0\0org.atheme.audacious\0Seek\0S\0pos\0I\0u\0\0org.atheme.audacious\0Volume\0S\0vl\0O\0F\0N\0i\0vr\0O\0F\0N\0i\0\0org.atheme.audacious\0SetVolume\0S\0vl\0I\0i\0vr\0I\0i\0\0org.atheme.audacious\0Balance\0S\0balance\0O\0F\0N\0i\0\0org.atheme.audacious\0Position\0S\0pos\0O\0F\0N\0u\0\0org.atheme.audacious\0Advance\0S\0\0org.atheme.audacious\0Reverse\0S\0\0org.atheme.audacious\0Length\0S\0length\0O\0F\0N\0i\0\0org.atheme.audacious\0SongTitle\0S\0pos\0I\0u\0title\0O\0F\0N\0s\0\0org.atheme.audacious\0SongFilename\0S\0pos\0I\0u\0filename\0O\0F\0N\0s\0\0org.atheme.audacious\0SongLength\0S\0pos\0I\0u\0length\0O\0F\0N\0i\0\0org.atheme.audacious\0SongFrames\0S\0pos\0I\0u\0length\0O\0F\0N\0i\0\0org.atheme.audacious\0SongTuple\0S\0pos\0I\0u\0tuple\0I\0s\0value\0O\0F\0N\0v\0\0org.atheme.audacious\0Jump\0S\0pos\0I\0u\0\0org.atheme.audacious\0Add\0S\0file\0I\0s\0\0org.atheme.audacious\0AddUrl\0S\0url\0I\0s\0\0org.atheme.audacious\0AddList\0S\0filenames\0I\0as\0\0org.atheme.audacious\0OpenList\0S\0filenames\0I\0as\0\0org.atheme.audacious\0OpenListToTemp\0S\0filenames\0I\0as\0\0org.atheme.audacious\0Delete\0S\0pos\0I\0u\0\0org.atheme.audacious\0Clear\0S\0\0org.atheme.audacious\0AutoAdvance\0S\0is_advance\0O\0F\0N\0b\0\0org.atheme.audacious\0ToggleAutoAdvance\0S\0\0org.atheme.audacious\0Repeat\0S\0is_repeat\0O\0F\0N\0b\0\0org.atheme.audacious\0ToggleRepeat\0S\0\0org.atheme.audacious\0Shuffle\0S\0is_shuffle\0O\0F\0N\0b\0\0org.atheme.audacious\0ToggleShuffle\0S\0\0org.atheme.audacious\0ShowPrefsBox\0S\0show\0I\0b\0\0org.atheme.audacious\0ShowAboutBox\0S\0show\0I\0b\0\0org.atheme.audacious\0ShowJtfBox\0S\0show\0I\0b\0\0org.atheme.audacious\0ShowFilebrowser\0S\0show\0I\0b\0\0org.atheme.audacious\0PlayPause\0S\0\0org.atheme.audacious\0QueueGetListPos\0S\0qpos\0I\0u\0pos\0O\0F\0N\0u\0\0org.atheme.audacious\0QueueGetQueuePos\0S\0pos\0I\0u\0qpos\0O\0F\0N\0u\0\0org.atheme.audacious\0GetInfo\0S\0rate\0O\0F\0N\0i\0freq\0O\0F\0N\0i\0nch\0O\0F\0N\0i\0\0org.atheme.audacious\0ToggleAot\0S\0ontop\0I\0b\0\0org.atheme.audacious\0GetPlayqueueLength\0S\0length\0O\0F\0N\0i\0\0org.atheme.audacious\0PlaylistInsUrlString\0S\0url\0I\0s\0pos\0I\0i\0\0org.atheme.audacious\0PlaylistAdd\0S\0list\0I\0s\0\0org.atheme.audacious\0PlayqueueAdd\0S\0pos\0I\0i\0\0org.atheme.audacious\0PlayqueueRemove\0S\0pos\0I\0i\0\0org.atheme.audacious\0PlayqueueClear\0S\0\0org.atheme.audacious\0PlayqueueIsQueued\0S\0pos\0I\0i\0is_queued\0O\0F\0N\0b\0\0org.atheme.audacious\0PlaylistEnqueueToTemp\0S\0url\0I\0s\0\0org.atheme.audacious\0GetEq\0S\0preamp\0O\0F\0N\0d\0bands\0O\0F\0N\0ad\0\0org.atheme.audacious\0GetEqPreamp\0S\0preamp\0O\0F\0N\0d\0\0org.atheme.audacious\0GetEqBand\0S\0band\0I\0i\0value\0O\0F\0N\0d\0\0org.atheme.audacious\0SetEq\0S\0preamp\0I\0d\0bands\0I\0ad\0\0org.atheme.audacious\0SetEqPreamp\0S\0preamp\0I\0d\0\0org.atheme.audacious\0SetEqBand\0S\0band\0I\0i\0value\0I\0d\0\0org.atheme.audacious\0EqualizerActivate\0S\0active\0I\0b\0\0org.atheme.audacious\0GetActivePlaylistName\0S\0plname\0O\0F\0N\0s\0\0\0",
00956 "\0",
00957 "\0"
00958 };
00959 
00960 /* Generated by dbus-binding-tool; do not edit! */
00961 
00962 
00963 #ifndef __dbus_glib_marshal_mpris_root_MARSHAL_H__
00964 #define __dbus_glib_marshal_mpris_root_MARSHAL_H__
00965 
00966 #include        <glib-object.h>
00967 
00968 G_BEGIN_DECLS
00969 
00970 #ifdef G_ENABLE_DEBUG
00971 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
00972 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
00973 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
00974 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
00975 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
00976 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
00977 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
00978 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
00979 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
00980 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
00981 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
00982 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
00983 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
00984 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
00985 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
00986 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
00987 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
00988 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
00989 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
00990 #else /* !G_ENABLE_DEBUG */
00991 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
00992  *          Do not access GValues directly in your code. Instead, use the
00993  *          g_value_get_*() functions
00994  */
00995 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
00996 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
00997 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
00998 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
00999 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01000 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01001 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01002 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01003 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01004 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01005 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01006 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01007 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01008 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01009 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01010 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01011 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01012 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01013 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01014 #endif /* !G_ENABLE_DEBUG */
01015 
01016 
01017 /* BOOLEAN:POINTER */
01018 extern void dbus_glib_marshal_mpris_root_BOOLEAN__POINTER (GClosure     *closure,
01019                                                            GValue       *return_value,
01020                                                            guint         n_param_values,
01021                                                            const GValue *param_values,
01022                                                            gpointer      invocation_hint,
01023                                                            gpointer      marshal_data);
01024 void
01025 dbus_glib_marshal_mpris_root_BOOLEAN__POINTER (GClosure     *closure,
01026                                                GValue       *return_value G_GNUC_UNUSED,
01027                                                guint         n_param_values,
01028                                                const GValue *param_values,
01029                                                gpointer      invocation_hint G_GNUC_UNUSED,
01030                                                gpointer      marshal_data)
01031 {
01032   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
01033                                                      gpointer     arg_1,
01034                                                      gpointer     data2);
01035   register GMarshalFunc_BOOLEAN__POINTER callback;
01036   register GCClosure *cc = (GCClosure*) closure;
01037   register gpointer data1, data2;
01038   gboolean v_return;
01039 
01040   g_return_if_fail (return_value != NULL);
01041   g_return_if_fail (n_param_values == 2);
01042 
01043   if (G_CCLOSURE_SWAP_DATA (closure))
01044     {
01045       data1 = closure->data;
01046       data2 = g_value_peek_pointer (param_values + 0);
01047     }
01048   else
01049     {
01050       data1 = g_value_peek_pointer (param_values + 0);
01051       data2 = closure->data;
01052     }
01053   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
01054 
01055   v_return = callback (data1,
01056                        g_marshal_value_peek_pointer (param_values + 1),
01057                        data2);
01058 
01059   g_value_set_boolean (return_value, v_return);
01060 }
01061 
01062 /* BOOLEAN:POINTER,POINTER */
01063 extern void dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01064                                                                    GValue       *return_value,
01065                                                                    guint         n_param_values,
01066                                                                    const GValue *param_values,
01067                                                                    gpointer      invocation_hint,
01068                                                                    gpointer      marshal_data);
01069 void
01070 dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01071                                                        GValue       *return_value G_GNUC_UNUSED,
01072                                                        guint         n_param_values,
01073                                                        const GValue *param_values,
01074                                                        gpointer      invocation_hint G_GNUC_UNUSED,
01075                                                        gpointer      marshal_data)
01076 {
01077   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01078                                                              gpointer     arg_1,
01079                                                              gpointer     arg_2,
01080                                                              gpointer     data2);
01081   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01082   register GCClosure *cc = (GCClosure*) closure;
01083   register gpointer data1, data2;
01084   gboolean v_return;
01085 
01086   g_return_if_fail (return_value != NULL);
01087   g_return_if_fail (n_param_values == 3);
01088 
01089   if (G_CCLOSURE_SWAP_DATA (closure))
01090     {
01091       data1 = closure->data;
01092       data2 = g_value_peek_pointer (param_values + 0);
01093     }
01094   else
01095     {
01096       data1 = g_value_peek_pointer (param_values + 0);
01097       data2 = closure->data;
01098     }
01099   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01100 
01101   v_return = callback (data1,
01102                        g_marshal_value_peek_pointer (param_values + 1),
01103                        g_marshal_value_peek_pointer (param_values + 2),
01104                        data2);
01105 
01106   g_value_set_boolean (return_value, v_return);
01107 }
01108 
01109 G_END_DECLS
01110 
01111 #endif /* __dbus_glib_marshal_mpris_root_MARSHAL_H__ */
01112 
01113 #include <dbus/dbus-glib.h>
01114 static const DBusGMethodInfo dbus_glib_mpris_root_methods[] = {
01115   { (GCallback) mpris_root_identity, dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER, 0 },
01116   { (GCallback) mpris_root_quit, dbus_glib_marshal_mpris_root_BOOLEAN__POINTER, 53 },
01117 };
01118 
01119 const DBusGObjectInfo dbus_glib_mpris_root_object_info = {  1,
01120   dbus_glib_mpris_root_methods,
01121   2,
01122 "org.freedesktop.MediaPlayer\0Identity\0S\0arg0\0O\0F\0N\0s\0\0org.freedesktop.MediaPlayer\0Quit\0S\0\0\0",
01123 "\0",
01124 "\0"
01125 };
01126 
01127 /* Generated by dbus-binding-tool; do not edit! */
01128 
01129 
01130 #ifndef __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__
01131 #define __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__
01132 
01133 #include        <glib-object.h>
01134 
01135 G_BEGIN_DECLS
01136 
01137 #ifdef G_ENABLE_DEBUG
01138 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
01139 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
01140 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
01141 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
01142 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
01143 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
01144 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
01145 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
01146 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
01147 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
01148 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
01149 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
01150 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
01151 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
01152 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
01153 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
01154 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
01155 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
01156 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
01157 #else /* !G_ENABLE_DEBUG */
01158 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
01159  *          Do not access GValues directly in your code. Instead, use the
01160  *          g_value_get_*() functions
01161  */
01162 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
01163 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
01164 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
01165 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
01166 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01167 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01168 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01169 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01170 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01171 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01172 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01173 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01174 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01175 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01176 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01177 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01178 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01179 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01180 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01181 #endif /* !G_ENABLE_DEBUG */
01182 
01183 
01184 /* BOOLEAN:INT,POINTER,POINTER */
01185 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
01186                                                                             GValue       *return_value,
01187                                                                             guint         n_param_values,
01188                                                                             const GValue *param_values,
01189                                                                             gpointer      invocation_hint,
01190                                                                             gpointer      marshal_data);
01191 void
01192 dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
01193                                                                 GValue       *return_value G_GNUC_UNUSED,
01194                                                                 guint         n_param_values,
01195                                                                 const GValue *param_values,
01196                                                                 gpointer      invocation_hint G_GNUC_UNUSED,
01197                                                                 gpointer      marshal_data)
01198 {
01199   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (gpointer     data1,
01200                                                                  gint         arg_1,
01201                                                                  gpointer     arg_2,
01202                                                                  gpointer     arg_3,
01203                                                                  gpointer     data2);
01204   register GMarshalFunc_BOOLEAN__INT_POINTER_POINTER callback;
01205   register GCClosure *cc = (GCClosure*) closure;
01206   register gpointer data1, data2;
01207   gboolean v_return;
01208 
01209   g_return_if_fail (return_value != NULL);
01210   g_return_if_fail (n_param_values == 4);
01211 
01212   if (G_CCLOSURE_SWAP_DATA (closure))
01213     {
01214       data1 = closure->data;
01215       data2 = g_value_peek_pointer (param_values + 0);
01216     }
01217   else
01218     {
01219       data1 = g_value_peek_pointer (param_values + 0);
01220       data2 = closure->data;
01221     }
01222   callback = (GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01223 
01224   v_return = callback (data1,
01225                        g_marshal_value_peek_int (param_values + 1),
01226                        g_marshal_value_peek_pointer (param_values + 2),
01227                        g_marshal_value_peek_pointer (param_values + 3),
01228                        data2);
01229 
01230   g_value_set_boolean (return_value, v_return);
01231 }
01232 
01233 /* BOOLEAN:POINTER,POINTER */
01234 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01235                                                                         GValue       *return_value,
01236                                                                         guint         n_param_values,
01237                                                                         const GValue *param_values,
01238                                                                         gpointer      invocation_hint,
01239                                                                         gpointer      marshal_data);
01240 void
01241 dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01242                                                             GValue       *return_value G_GNUC_UNUSED,
01243                                                             guint         n_param_values,
01244                                                             const GValue *param_values,
01245                                                             gpointer      invocation_hint G_GNUC_UNUSED,
01246                                                             gpointer      marshal_data)
01247 {
01248   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01249                                                              gpointer     arg_1,
01250                                                              gpointer     arg_2,
01251                                                              gpointer     data2);
01252   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01253   register GCClosure *cc = (GCClosure*) closure;
01254   register gpointer data1, data2;
01255   gboolean v_return;
01256 
01257   g_return_if_fail (return_value != NULL);
01258   g_return_if_fail (n_param_values == 3);
01259 
01260   if (G_CCLOSURE_SWAP_DATA (closure))
01261     {
01262       data1 = closure->data;
01263       data2 = g_value_peek_pointer (param_values + 0);
01264     }
01265   else
01266     {
01267       data1 = g_value_peek_pointer (param_values + 0);
01268       data2 = closure->data;
01269     }
01270   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01271 
01272   v_return = callback (data1,
01273                        g_marshal_value_peek_pointer (param_values + 1),
01274                        g_marshal_value_peek_pointer (param_values + 2),
01275                        data2);
01276 
01277   g_value_set_boolean (return_value, v_return);
01278 }
01279 
01280 /* BOOLEAN:INT,POINTER */
01281 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER (GClosure     *closure,
01282                                                                     GValue       *return_value,
01283                                                                     guint         n_param_values,
01284                                                                     const GValue *param_values,
01285                                                                     gpointer      invocation_hint,
01286                                                                     gpointer      marshal_data);
01287 void
01288 dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER (GClosure     *closure,
01289                                                         GValue       *return_value G_GNUC_UNUSED,
01290                                                         guint         n_param_values,
01291                                                         const GValue *param_values,
01292                                                         gpointer      invocation_hint G_GNUC_UNUSED,
01293                                                         gpointer      marshal_data)
01294 {
01295   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER) (gpointer     data1,
01296                                                          gint         arg_1,
01297                                                          gpointer     arg_2,
01298                                                          gpointer     data2);
01299   register GMarshalFunc_BOOLEAN__INT_POINTER callback;
01300   register GCClosure *cc = (GCClosure*) closure;
01301   register gpointer data1, data2;
01302   gboolean v_return;
01303 
01304   g_return_if_fail (return_value != NULL);
01305   g_return_if_fail (n_param_values == 3);
01306 
01307   if (G_CCLOSURE_SWAP_DATA (closure))
01308     {
01309       data1 = closure->data;
01310       data2 = g_value_peek_pointer (param_values + 0);
01311     }
01312   else
01313     {
01314       data1 = g_value_peek_pointer (param_values + 0);
01315       data2 = closure->data;
01316     }
01317   callback = (GMarshalFunc_BOOLEAN__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
01318 
01319   v_return = callback (data1,
01320                        g_marshal_value_peek_int (param_values + 1),
01321                        g_marshal_value_peek_pointer (param_values + 2),
01322                        data2);
01323 
01324   g_value_set_boolean (return_value, v_return);
01325 }
01326 
01327 /* BOOLEAN:STRING,BOOLEAN,POINTER */
01328 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER (GClosure     *closure,
01329                                                                                GValue       *return_value,
01330                                                                                guint         n_param_values,
01331                                                                                const GValue *param_values,
01332                                                                                gpointer      invocation_hint,
01333                                                                                gpointer      marshal_data);
01334 void
01335 dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER (GClosure     *closure,
01336                                                                    GValue       *return_value G_GNUC_UNUSED,
01337                                                                    guint         n_param_values,
01338                                                                    const GValue *param_values,
01339                                                                    gpointer      invocation_hint G_GNUC_UNUSED,
01340                                                                    gpointer      marshal_data)
01341 {
01342   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER) (gpointer     data1,
01343                                                                     gpointer     arg_1,
01344                                                                     gboolean     arg_2,
01345                                                                     gpointer     arg_3,
01346                                                                     gpointer     data2);
01347   register GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER callback;
01348   register GCClosure *cc = (GCClosure*) closure;
01349   register gpointer data1, data2;
01350   gboolean v_return;
01351 
01352   g_return_if_fail (return_value != NULL);
01353   g_return_if_fail (n_param_values == 4);
01354 
01355   if (G_CCLOSURE_SWAP_DATA (closure))
01356     {
01357       data1 = closure->data;
01358       data2 = g_value_peek_pointer (param_values + 0);
01359     }
01360   else
01361     {
01362       data1 = g_value_peek_pointer (param_values + 0);
01363       data2 = closure->data;
01364     }
01365   callback = (GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01366 
01367   v_return = callback (data1,
01368                        g_marshal_value_peek_string (param_values + 1),
01369                        g_marshal_value_peek_boolean (param_values + 2),
01370                        g_marshal_value_peek_pointer (param_values + 3),
01371                        data2);
01372 
01373   g_value_set_boolean (return_value, v_return);
01374 }
01375 
01376 /* BOOLEAN:BOOLEAN,POINTER */
01377 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01378                                                                         GValue       *return_value,
01379                                                                         guint         n_param_values,
01380                                                                         const GValue *param_values,
01381                                                                         gpointer      invocation_hint,
01382                                                                         gpointer      marshal_data);
01383 void
01384 dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01385                                                             GValue       *return_value G_GNUC_UNUSED,
01386                                                             guint         n_param_values,
01387                                                             const GValue *param_values,
01388                                                             gpointer      invocation_hint G_GNUC_UNUSED,
01389                                                             gpointer      marshal_data)
01390 {
01391   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
01392                                                              gboolean     arg_1,
01393                                                              gpointer     arg_2,
01394                                                              gpointer     data2);
01395   register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
01396   register GCClosure *cc = (GCClosure*) closure;
01397   register gpointer data1, data2;
01398   gboolean v_return;
01399 
01400   g_return_if_fail (return_value != NULL);
01401   g_return_if_fail (n_param_values == 3);
01402 
01403   if (G_CCLOSURE_SWAP_DATA (closure))
01404     {
01405       data1 = closure->data;
01406       data2 = g_value_peek_pointer (param_values + 0);
01407     }
01408   else
01409     {
01410       data1 = g_value_peek_pointer (param_values + 0);
01411       data2 = closure->data;
01412     }
01413   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01414 
01415   v_return = callback (data1,
01416                        g_marshal_value_peek_boolean (param_values + 1),
01417                        g_marshal_value_peek_pointer (param_values + 2),
01418                        data2);
01419 
01420   g_value_set_boolean (return_value, v_return);
01421 }
01422 
01423 G_END_DECLS
01424 
01425 #endif /* __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__ */
01426 
01427 #include <dbus/dbus-glib.h>
01428 static const DBusGMethodInfo dbus_glib_mpris_tracklist_methods[] = {
01429   { (GCallback) mpris_tracklist_get_metadata, dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER, 0 },
01430   { (GCallback) mpris_tracklist_get_current_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER, 69 },
01431   { (GCallback) mpris_tracklist_get_length, dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER, 129 },
01432   { (GCallback) mpris_tracklist_add_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER, 183 },
01433   { (GCallback) mpris_tracklist_del_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER, 241 },
01434   { (GCallback) mpris_tracklist_loop, dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER, 290 },
01435   { (GCallback) mpris_tracklist_random, dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER, 335 },
01436 };
01437 
01438 const DBusGObjectInfo dbus_glib_mpris_tracklist_object_info = {  1,
01439   dbus_glib_mpris_tracklist_methods,
01440   7,
01441 "org.freedesktop.MediaPlayer\0GetMetadata\0S\0arg0\0I\0i\0arg1\0O\0F\0N\0a{sv}\0\0org.freedesktop.MediaPlayer\0GetCurrentTrack\0S\0arg0\0O\0F\0N\0i\0\0org.freedesktop.MediaPlayer\0GetLength\0S\0arg0\0O\0F\0N\0i\0\0org.freedesktop.MediaPlayer\0AddTrack\0S\0arg0\0I\0s\0arg1\0I\0b\0\0org.freedesktop.MediaPlayer\0DelTrack\0S\0arg0\0I\0i\0\0org.freedesktop.MediaPlayer\0Loop\0S\0arg0\0I\0b\0\0org.freedesktop.MediaPlayer\0Random\0S\0arg0\0I\0b\0\0\0",
01442 "org.freedesktop.MediaPlayer\0TrackListChange\0\0",
01443 "\0"
01444 };
01445 
01446 /* Generated by dbus-binding-tool; do not edit! */
01447 
01448 
01449 #ifndef __dbus_glib_marshal_mpris_player_MARSHAL_H__
01450 #define __dbus_glib_marshal_mpris_player_MARSHAL_H__
01451 
01452 #include        <glib-object.h>
01453 
01454 G_BEGIN_DECLS
01455 
01456 #ifdef G_ENABLE_DEBUG
01457 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
01458 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
01459 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
01460 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
01461 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
01462 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
01463 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
01464 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
01465 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
01466 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
01467 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
01468 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
01469 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
01470 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
01471 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
01472 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
01473 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
01474 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
01475 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
01476 #else /* !G_ENABLE_DEBUG */
01477 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
01478  *          Do not access GValues directly in your code. Instead, use the
01479  *          g_value_get_*() functions
01480  */
01481 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
01482 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
01483 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
01484 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
01485 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01486 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01487 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01488 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01489 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01490 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01491 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01492 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01493 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01494 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01495 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01496 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01497 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01498 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01499 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01500 #endif /* !G_ENABLE_DEBUG */
01501 
01502 
01503 /* BOOLEAN:POINTER */
01504 extern void dbus_glib_marshal_mpris_player_BOOLEAN__POINTER (GClosure     *closure,
01505                                                              GValue       *return_value,
01506                                                              guint         n_param_values,
01507                                                              const GValue *param_values,
01508                                                              gpointer      invocation_hint,
01509                                                              gpointer      marshal_data);
01510 void
01511 dbus_glib_marshal_mpris_player_BOOLEAN__POINTER (GClosure     *closure,
01512                                                  GValue       *return_value G_GNUC_UNUSED,
01513                                                  guint         n_param_values,
01514                                                  const GValue *param_values,
01515                                                  gpointer      invocation_hint G_GNUC_UNUSED,
01516                                                  gpointer      marshal_data)
01517 {
01518   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
01519                                                      gpointer     arg_1,
01520                                                      gpointer     data2);
01521   register GMarshalFunc_BOOLEAN__POINTER callback;
01522   register GCClosure *cc = (GCClosure*) closure;
01523   register gpointer data1, data2;
01524   gboolean v_return;
01525 
01526   g_return_if_fail (return_value != NULL);
01527   g_return_if_fail (n_param_values == 2);
01528 
01529   if (G_CCLOSURE_SWAP_DATA (closure))
01530     {
01531       data1 = closure->data;
01532       data2 = g_value_peek_pointer (param_values + 0);
01533     }
01534   else
01535     {
01536       data1 = g_value_peek_pointer (param_values + 0);
01537       data2 = closure->data;
01538     }
01539   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
01540 
01541   v_return = callback (data1,
01542                        g_marshal_value_peek_pointer (param_values + 1),
01543                        data2);
01544 
01545   g_value_set_boolean (return_value, v_return);
01546 }
01547 
01548 /* BOOLEAN:POINTER,POINTER */
01549 extern void dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01550                                                                      GValue       *return_value,
01551                                                                      guint         n_param_values,
01552                                                                      const GValue *param_values,
01553                                                                      gpointer      invocation_hint,
01554                                                                      gpointer      marshal_data);
01555 void
01556 dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01557                                                          GValue       *return_value G_GNUC_UNUSED,
01558                                                          guint         n_param_values,
01559                                                          const GValue *param_values,
01560                                                          gpointer      invocation_hint G_GNUC_UNUSED,
01561                                                          gpointer      marshal_data)
01562 {
01563   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01564                                                              gpointer     arg_1,
01565                                                              gpointer     arg_2,
01566                                                              gpointer     data2);
01567   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01568   register GCClosure *cc = (GCClosure*) closure;
01569   register gpointer data1, data2;
01570   gboolean v_return;
01571 
01572   g_return_if_fail (return_value != NULL);
01573   g_return_if_fail (n_param_values == 3);
01574 
01575   if (G_CCLOSURE_SWAP_DATA (closure))
01576     {
01577       data1 = closure->data;
01578       data2 = g_value_peek_pointer (param_values + 0);
01579     }
01580   else
01581     {
01582       data1 = g_value_peek_pointer (param_values + 0);
01583       data2 = closure->data;
01584     }
01585   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01586 
01587   v_return = callback (data1,
01588                        g_marshal_value_peek_pointer (param_values + 1),
01589                        g_marshal_value_peek_pointer (param_values + 2),
01590                        data2);
01591 
01592   g_value_set_boolean (return_value, v_return);
01593 }
01594 
01595 /* BOOLEAN:INT,POINTER */
01596 extern void dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER (GClosure     *closure,
01597                                                                  GValue       *return_value,
01598                                                                  guint         n_param_values,
01599                                                                  const GValue *param_values,
01600                                                                  gpointer      invocation_hint,
01601                                                                  gpointer      marshal_data);
01602 void
01603 dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER (GClosure     *closure,
01604                                                      GValue       *return_value G_GNUC_UNUSED,
01605                                                      guint         n_param_values,
01606                                                      const GValue *param_values,
01607                                                      gpointer      invocation_hint G_GNUC_UNUSED,
01608                                                      gpointer      marshal_data)
01609 {
01610   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER) (gpointer     data1,
01611                                                          gint         arg_1,
01612                                                          gpointer     arg_2,
01613                                                          gpointer     data2);
01614   register GMarshalFunc_BOOLEAN__INT_POINTER callback;
01615   register GCClosure *cc = (GCClosure*) closure;
01616   register gpointer data1, data2;
01617   gboolean v_return;
01618 
01619   g_return_if_fail (return_value != NULL);
01620   g_return_if_fail (n_param_values == 3);
01621 
01622   if (G_CCLOSURE_SWAP_DATA (closure))
01623     {
01624       data1 = closure->data;
01625       data2 = g_value_peek_pointer (param_values + 0);
01626     }
01627   else
01628     {
01629       data1 = g_value_peek_pointer (param_values + 0);
01630       data2 = closure->data;
01631     }
01632   callback = (GMarshalFunc_BOOLEAN__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
01633 
01634   v_return = callback (data1,
01635                        g_marshal_value_peek_int (param_values + 1),
01636                        g_marshal_value_peek_pointer (param_values + 2),
01637                        data2);
01638 
01639   g_value_set_boolean (return_value, v_return);
01640 }
01641 
01642 /* BOOLEAN:BOOLEAN,POINTER */
01643 extern void dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01644                                                                      GValue       *return_value,
01645                                                                      guint         n_param_values,
01646                                                                      const GValue *param_values,
01647                                                                      gpointer      invocation_hint,
01648                                                                      gpointer      marshal_data);
01649 void
01650 dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01651                                                          GValue       *return_value G_GNUC_UNUSED,
01652                                                          guint         n_param_values,
01653                                                          const GValue *param_values,
01654                                                          gpointer      invocation_hint G_GNUC_UNUSED,
01655                                                          gpointer      marshal_data)
01656 {
01657   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
01658                                                              gboolean     arg_1,
01659                                                              gpointer     arg_2,
01660                                                              gpointer     data2);
01661   register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
01662   register GCClosure *cc = (GCClosure*) closure;
01663   register gpointer data1, data2;
01664   gboolean v_return;
01665 
01666   g_return_if_fail (return_value != NULL);
01667   g_return_if_fail (n_param_values == 3);
01668 
01669   if (G_CCLOSURE_SWAP_DATA (closure))
01670     {
01671       data1 = closure->data;
01672       data2 = g_value_peek_pointer (param_values + 0);
01673     }
01674   else
01675     {
01676       data1 = g_value_peek_pointer (param_values + 0);
01677       data2 = closure->data;
01678     }
01679   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01680 
01681   v_return = callback (data1,
01682                        g_marshal_value_peek_boolean (param_values + 1),
01683                        g_marshal_value_peek_pointer (param_values + 2),
01684                        data2);
01685 
01686   g_value_set_boolean (return_value, v_return);
01687 }
01688 
01689 G_END_DECLS
01690 
01691 #endif /* __dbus_glib_marshal_mpris_player_MARSHAL_H__ */
01692 
01693 #include <dbus/dbus-glib.h>
01694 static const DBusGMethodInfo dbus_glib_mpris_player_methods[] = {
01695   { (GCallback) mpris_player_next, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 0 },
01696   { (GCallback) mpris_player_prev, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 36 },
01697   { (GCallback) mpris_player_pause, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 72 },
01698   { (GCallback) mpris_player_stop, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 109 },
01699   { (GCallback) mpris_player_play, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 145 },
01700   { (GCallback) mpris_player_repeat, dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER, 181 },
01701   { (GCallback) mpris_player_get_status, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 228 },
01702   { (GCallback) mpris_player_get_metadata, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 287 },
01703   { (GCallback) mpris_player_get_caps, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 347 },
01704   { (GCallback) mpris_player_volume_set, dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER, 399 },
01705   { (GCallback) mpris_player_volume_get, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 449 },
01706   { (GCallback) mpris_player_position_set, dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER, 503 },
01707   { (GCallback) mpris_player_position_get, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 555 },
01708 };
01709 
01710 const DBusGObjectInfo dbus_glib_mpris_player_object_info = {  1,
01711   dbus_glib_mpris_player_methods,
01712   13,
01713 "org.freedesktop.MediaPlayer\0Next\0S\0\0org.freedesktop.MediaPlayer\0Prev\0S\0\0org.freedesktop.MediaPlayer\0Pause\0S\0\0org.freedesktop.MediaPlayer\0Stop\0S\0\0org.freedesktop.MediaPlayer\0Play\0S\0\0org.freedesktop.MediaPlayer\0Repeat\0S\0arg0\0I\0b\0\0org.freedesktop.MediaPlayer\0GetStatus\0S\0arg0\0O\0F\0N\0(iiii)\0\0org.freedesktop.MediaPlayer\0GetMetadata\0S\0arg0\0O\0F\0N\0a{sv}\0\0org.freedesktop.MediaPlayer\0GetCaps\0S\0arg0\0O\0F\0N\0i\0\0org.freedesktop.MediaPlayer\0VolumeSet\0S\0arg0\0I\0i\0\0org.freedesktop.MediaPlayer\0VolumeGet\0S\0arg0\0O\0F\0N\0i\0\0org.freedesktop.MediaPlayer\0PositionSet\0S\0arg0\0I\0i\0\0org.freedesktop.MediaPlayer\0PositionGet\0S\0arg0\0O\0F\0N\0i\0\0\0",
01714 "org.freedesktop.MediaPlayer\0TrackChange\0org.freedesktop.MediaPlayer\0StatusChange\0org.freedesktop.MediaPlayer\0CapsChange\0\0",
01715 "\0"
01716 };
01717