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:DOUBLE,POINTER */
00106 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__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__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__DOUBLE_POINTER) (gpointer     data1,
00121                                                             gdouble      arg_1,
00122                                                             gpointer     arg_2,
00123                                                             gpointer     data2);
00124   register GMarshalFunc_BOOLEAN__DOUBLE_POINTER callback;
00125   register GCClosure *cc = (GCClosure*) closure;
00126   register gpointer data1, data2;
00127   gboolean v_return;
00128 
00129   g_return_if_fail (return_value != NULL);
00130   g_return_if_fail (n_param_values == 3);
00131 
00132   if (G_CCLOSURE_SWAP_DATA (closure))
00133     {
00134       data1 = closure->data;
00135       data2 = g_value_peek_pointer (param_values + 0);
00136     }
00137   else
00138     {
00139       data1 = g_value_peek_pointer (param_values + 0);
00140       data2 = closure->data;
00141     }
00142   callback = (GMarshalFunc_BOOLEAN__DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
00143 
00144   v_return = callback (data1,
00145                        g_marshal_value_peek_double (param_values + 1),
00146                        g_marshal_value_peek_pointer (param_values + 2),
00147                        data2);
00148 
00149   g_value_set_boolean (return_value, v_return);
00150 }
00151 
00152 /* BOOLEAN:INT,INT,POINTER */
00153 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER (GClosure     *closure,
00154                                                                      GValue       *return_value,
00155                                                                      guint         n_param_values,
00156                                                                      const GValue *param_values,
00157                                                                      gpointer      invocation_hint,
00158                                                                      gpointer      marshal_data);
00159 void
00160 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER (GClosure     *closure,
00161                                                          GValue       *return_value G_GNUC_UNUSED,
00162                                                          guint         n_param_values,
00163                                                          const GValue *param_values,
00164                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00165                                                          gpointer      marshal_data)
00166 {
00167   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_INT_POINTER) (gpointer     data1,
00168                                                              gint         arg_1,
00169                                                              gint         arg_2,
00170                                                              gpointer     arg_3,
00171                                                              gpointer     data2);
00172   register GMarshalFunc_BOOLEAN__INT_INT_POINTER callback;
00173   register GCClosure *cc = (GCClosure*) closure;
00174   register gpointer data1, data2;
00175   gboolean v_return;
00176 
00177   g_return_if_fail (return_value != NULL);
00178   g_return_if_fail (n_param_values == 4);
00179 
00180   if (G_CCLOSURE_SWAP_DATA (closure))
00181     {
00182       data1 = closure->data;
00183       data2 = g_value_peek_pointer (param_values + 0);
00184     }
00185   else
00186     {
00187       data1 = g_value_peek_pointer (param_values + 0);
00188       data2 = closure->data;
00189     }
00190   callback = (GMarshalFunc_BOOLEAN__INT_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00191 
00192   v_return = callback (data1,
00193                        g_marshal_value_peek_int (param_values + 1),
00194                        g_marshal_value_peek_int (param_values + 2),
00195                        g_marshal_value_peek_pointer (param_values + 3),
00196                        data2);
00197 
00198   g_value_set_boolean (return_value, v_return);
00199 }
00200 
00201 /* BOOLEAN:STRING,INT,POINTER */
00202 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER (GClosure     *closure,
00203                                                                         GValue       *return_value,
00204                                                                         guint         n_param_values,
00205                                                                         const GValue *param_values,
00206                                                                         gpointer      invocation_hint,
00207                                                                         gpointer      marshal_data);
00208 void
00209 dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER (GClosure     *closure,
00210                                                             GValue       *return_value G_GNUC_UNUSED,
00211                                                             guint         n_param_values,
00212                                                             const GValue *param_values,
00213                                                             gpointer      invocation_hint G_GNUC_UNUSED,
00214                                                             gpointer      marshal_data)
00215 {
00216   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_INT_POINTER) (gpointer     data1,
00217                                                                 gpointer     arg_1,
00218                                                                 gint         arg_2,
00219                                                                 gpointer     arg_3,
00220                                                                 gpointer     data2);
00221   register GMarshalFunc_BOOLEAN__STRING_INT_POINTER callback;
00222   register GCClosure *cc = (GCClosure*) closure;
00223   register gpointer data1, data2;
00224   gboolean v_return;
00225 
00226   g_return_if_fail (return_value != NULL);
00227   g_return_if_fail (n_param_values == 4);
00228 
00229   if (G_CCLOSURE_SWAP_DATA (closure))
00230     {
00231       data1 = closure->data;
00232       data2 = g_value_peek_pointer (param_values + 0);
00233     }
00234   else
00235     {
00236       data1 = g_value_peek_pointer (param_values + 0);
00237       data2 = closure->data;
00238     }
00239   callback = (GMarshalFunc_BOOLEAN__STRING_INT_POINTER) (marshal_data ? marshal_data : cc->callback);
00240 
00241   v_return = callback (data1,
00242                        g_marshal_value_peek_string (param_values + 1),
00243                        g_marshal_value_peek_int (param_values + 2),
00244                        g_marshal_value_peek_pointer (param_values + 3),
00245                        data2);
00246 
00247   g_value_set_boolean (return_value, v_return);
00248 }
00249 
00250 /* BOOLEAN:POINTER,POINTER,POINTER,POINTER */
00251 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER (GClosure     *closure,
00252                                                                                      GValue       *return_value,
00253                                                                                      guint         n_param_values,
00254                                                                                      const GValue *param_values,
00255                                                                                      gpointer      invocation_hint,
00256                                                                                      gpointer      marshal_data);
00257 void
00258 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER (GClosure     *closure,
00259                                                                          GValue       *return_value G_GNUC_UNUSED,
00260                                                                          guint         n_param_values,
00261                                                                          const GValue *param_values,
00262                                                                          gpointer      invocation_hint G_GNUC_UNUSED,
00263                                                                          gpointer      marshal_data)
00264 {
00265   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER) (gpointer     data1,
00266                                                                              gpointer     arg_1,
00267                                                                              gpointer     arg_2,
00268                                                                              gpointer     arg_3,
00269                                                                              gpointer     arg_4,
00270                                                                              gpointer     data2);
00271   register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER callback;
00272   register GCClosure *cc = (GCClosure*) closure;
00273   register gpointer data1, data2;
00274   gboolean v_return;
00275 
00276   g_return_if_fail (return_value != NULL);
00277   g_return_if_fail (n_param_values == 5);
00278 
00279   if (G_CCLOSURE_SWAP_DATA (closure))
00280     {
00281       data1 = closure->data;
00282       data2 = g_value_peek_pointer (param_values + 0);
00283     }
00284   else
00285     {
00286       data1 = g_value_peek_pointer (param_values + 0);
00287       data2 = closure->data;
00288     }
00289   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00290 
00291   v_return = callback (data1,
00292                        g_marshal_value_peek_pointer (param_values + 1),
00293                        g_marshal_value_peek_pointer (param_values + 2),
00294                        g_marshal_value_peek_pointer (param_values + 3),
00295                        g_marshal_value_peek_pointer (param_values + 4),
00296                        data2);
00297 
00298   g_value_set_boolean (return_value, v_return);
00299 }
00300 
00301 /* BOOLEAN:BOXED,POINTER */
00302 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER (GClosure     *closure,
00303                                                                    GValue       *return_value,
00304                                                                    guint         n_param_values,
00305                                                                    const GValue *param_values,
00306                                                                    gpointer      invocation_hint,
00307                                                                    gpointer      marshal_data);
00308 void
00309 dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER (GClosure     *closure,
00310                                                        GValue       *return_value G_GNUC_UNUSED,
00311                                                        guint         n_param_values,
00312                                                        const GValue *param_values,
00313                                                        gpointer      invocation_hint G_GNUC_UNUSED,
00314                                                        gpointer      marshal_data)
00315 {
00316   typedef gboolean (*GMarshalFunc_BOOLEAN__BOXED_POINTER) (gpointer     data1,
00317                                                            gpointer     arg_1,
00318                                                            gpointer     arg_2,
00319                                                            gpointer     data2);
00320   register GMarshalFunc_BOOLEAN__BOXED_POINTER callback;
00321   register GCClosure *cc = (GCClosure*) closure;
00322   register gpointer data1, data2;
00323   gboolean v_return;
00324 
00325   g_return_if_fail (return_value != NULL);
00326   g_return_if_fail (n_param_values == 3);
00327 
00328   if (G_CCLOSURE_SWAP_DATA (closure))
00329     {
00330       data1 = closure->data;
00331       data2 = g_value_peek_pointer (param_values + 0);
00332     }
00333   else
00334     {
00335       data1 = g_value_peek_pointer (param_values + 0);
00336       data2 = closure->data;
00337     }
00338   callback = (GMarshalFunc_BOOLEAN__BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
00339 
00340   v_return = callback (data1,
00341                        g_marshal_value_peek_boxed (param_values + 1),
00342                        g_marshal_value_peek_pointer (param_values + 2),
00343                        data2);
00344 
00345   g_value_set_boolean (return_value, v_return);
00346 }
00347 
00348 /* BOOLEAN:BOOLEAN,POINTER */
00349 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_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__BOOLEAN_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__BOOLEAN_POINTER) (gpointer     data1,
00364                                                              gboolean     arg_1,
00365                                                              gpointer     arg_2,
00366                                                              gpointer     data2);
00367   register GMarshalFunc_BOOLEAN__BOOLEAN_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__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
00386 
00387   v_return = callback (data1,
00388                        g_marshal_value_peek_boolean (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:UINT,POINTER,POINTER */
00396 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_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__UINT_POINTER_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__UINT_POINTER_POINTER) (gpointer     data1,
00411                                                                   guint        arg_1,
00412                                                                   gpointer     arg_2,
00413                                                                   gpointer     arg_3,
00414                                                                   gpointer     data2);
00415   register GMarshalFunc_BOOLEAN__UINT_POINTER_POINTER callback;
00416   register GCClosure *cc = (GCClosure*) closure;
00417   register gpointer data1, data2;
00418   gboolean v_return;
00419 
00420   g_return_if_fail (return_value != NULL);
00421   g_return_if_fail (n_param_values == 4);
00422 
00423   if (G_CCLOSURE_SWAP_DATA (closure))
00424     {
00425       data1 = closure->data;
00426       data2 = g_value_peek_pointer (param_values + 0);
00427     }
00428   else
00429     {
00430       data1 = g_value_peek_pointer (param_values + 0);
00431       data2 = closure->data;
00432     }
00433   callback = (GMarshalFunc_BOOLEAN__UINT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00434 
00435   v_return = callback (data1,
00436                        g_marshal_value_peek_uint (param_values + 1),
00437                        g_marshal_value_peek_pointer (param_values + 2),
00438                        g_marshal_value_peek_pointer (param_values + 3),
00439                        data2);
00440 
00441   g_value_set_boolean (return_value, v_return);
00442 }
00443 
00444 /* BOOLEAN:INT,DOUBLE,POINTER */
00445 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER (GClosure     *closure,
00446                                                                         GValue       *return_value,
00447                                                                         guint         n_param_values,
00448                                                                         const GValue *param_values,
00449                                                                         gpointer      invocation_hint,
00450                                                                         gpointer      marshal_data);
00451 void
00452 dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER (GClosure     *closure,
00453                                                             GValue       *return_value G_GNUC_UNUSED,
00454                                                             guint         n_param_values,
00455                                                             const GValue *param_values,
00456                                                             gpointer      invocation_hint G_GNUC_UNUSED,
00457                                                             gpointer      marshal_data)
00458 {
00459   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER) (gpointer     data1,
00460                                                                 gint         arg_1,
00461                                                                 gdouble      arg_2,
00462                                                                 gpointer     arg_3,
00463                                                                 gpointer     data2);
00464   register GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER callback;
00465   register GCClosure *cc = (GCClosure*) closure;
00466   register gpointer data1, data2;
00467   gboolean v_return;
00468 
00469   g_return_if_fail (return_value != NULL);
00470   g_return_if_fail (n_param_values == 4);
00471 
00472   if (G_CCLOSURE_SWAP_DATA (closure))
00473     {
00474       data1 = closure->data;
00475       data2 = g_value_peek_pointer (param_values + 0);
00476     }
00477   else
00478     {
00479       data1 = g_value_peek_pointer (param_values + 0);
00480       data2 = closure->data;
00481     }
00482   callback = (GMarshalFunc_BOOLEAN__INT_DOUBLE_POINTER) (marshal_data ? marshal_data : cc->callback);
00483 
00484   v_return = callback (data1,
00485                        g_marshal_value_peek_int (param_values + 1),
00486                        g_marshal_value_peek_double (param_values + 2),
00487                        g_marshal_value_peek_pointer (param_values + 3),
00488                        data2);
00489 
00490   g_value_set_boolean (return_value, v_return);
00491 }
00492 
00493 /* BOOLEAN:POINTER */
00494 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER (GClosure     *closure,
00495                                                              GValue       *return_value,
00496                                                              guint         n_param_values,
00497                                                              const GValue *param_values,
00498                                                              gpointer      invocation_hint,
00499                                                              gpointer      marshal_data);
00500 void
00501 dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER (GClosure     *closure,
00502                                                  GValue       *return_value G_GNUC_UNUSED,
00503                                                  guint         n_param_values,
00504                                                  const GValue *param_values,
00505                                                  gpointer      invocation_hint G_GNUC_UNUSED,
00506                                                  gpointer      marshal_data)
00507 {
00508   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
00509                                                      gpointer     arg_1,
00510                                                      gpointer     data2);
00511   register GMarshalFunc_BOOLEAN__POINTER callback;
00512   register GCClosure *cc = (GCClosure*) closure;
00513   register gpointer data1, data2;
00514   gboolean v_return;
00515 
00516   g_return_if_fail (return_value != NULL);
00517   g_return_if_fail (n_param_values == 2);
00518 
00519   if (G_CCLOSURE_SWAP_DATA (closure))
00520     {
00521       data1 = closure->data;
00522       data2 = g_value_peek_pointer (param_values + 0);
00523     }
00524   else
00525     {
00526       data1 = g_value_peek_pointer (param_values + 0);
00527       data2 = closure->data;
00528     }
00529   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
00530 
00531   v_return = callback (data1,
00532                        g_marshal_value_peek_pointer (param_values + 1),
00533                        data2);
00534 
00535   g_value_set_boolean (return_value, v_return);
00536 }
00537 
00538 /* BOOLEAN:INT,POINTER,POINTER */
00539 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_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__INT_POINTER_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__INT_POINTER_POINTER) (gpointer     data1,
00554                                                                  gint         arg_1,
00555                                                                  gpointer     arg_2,
00556                                                                  gpointer     arg_3,
00557                                                                  gpointer     data2);
00558   register GMarshalFunc_BOOLEAN__INT_POINTER_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__INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00577 
00578   v_return = callback (data1,
00579                        g_marshal_value_peek_int (param_values + 1),
00580                        g_marshal_value_peek_pointer (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:DOUBLE,BOXED,POINTER */
00588 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_BOXED_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__DOUBLE_BOXED_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__DOUBLE_BOXED_POINTER) (gpointer     data1,
00603                                                                   gdouble      arg_1,
00604                                                                   gpointer     arg_2,
00605                                                                   gpointer     arg_3,
00606                                                                   gpointer     data2);
00607   register GMarshalFunc_BOOLEAN__DOUBLE_BOXED_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__DOUBLE_BOXED_POINTER) (marshal_data ? marshal_data : cc->callback);
00626 
00627   v_return = callback (data1,
00628                        g_marshal_value_peek_double (param_values + 1),
00629                        g_marshal_value_peek_boxed (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,STRING,POINTER,POINTER */
00637 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_STRING_POINTER_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_STRING_POINTER_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_STRING_POINTER_POINTER) (gpointer     data1,
00652                                                                          guint        arg_1,
00653                                                                          gpointer     arg_2,
00654                                                                          gpointer     arg_3,
00655                                                                          gpointer     arg_4,
00656                                                                          gpointer     data2);
00657   register GMarshalFunc_BOOLEAN__UINT_STRING_POINTER_POINTER callback;
00658   register GCClosure *cc = (GCClosure*) closure;
00659   register gpointer data1, data2;
00660   gboolean v_return;
00661 
00662   g_return_if_fail (return_value != NULL);
00663   g_return_if_fail (n_param_values == 5);
00664 
00665   if (G_CCLOSURE_SWAP_DATA (closure))
00666     {
00667       data1 = closure->data;
00668       data2 = g_value_peek_pointer (param_values + 0);
00669     }
00670   else
00671     {
00672       data1 = g_value_peek_pointer (param_values + 0);
00673       data2 = closure->data;
00674     }
00675   callback = (GMarshalFunc_BOOLEAN__UINT_STRING_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00676 
00677   v_return = callback (data1,
00678                        g_marshal_value_peek_uint (param_values + 1),
00679                        g_marshal_value_peek_string (param_values + 2),
00680                        g_marshal_value_peek_pointer (param_values + 3),
00681                        g_marshal_value_peek_pointer (param_values + 4),
00682                        data2);
00683 
00684   g_value_set_boolean (return_value, v_return);
00685 }
00686 
00687 /* BOOLEAN:UINT,POINTER */
00688 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER (GClosure     *closure,
00689                                                                   GValue       *return_value,
00690                                                                   guint         n_param_values,
00691                                                                   const GValue *param_values,
00692                                                                   gpointer      invocation_hint,
00693                                                                   gpointer      marshal_data);
00694 void
00695 dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER (GClosure     *closure,
00696                                                       GValue       *return_value G_GNUC_UNUSED,
00697                                                       guint         n_param_values,
00698                                                       const GValue *param_values,
00699                                                       gpointer      invocation_hint G_GNUC_UNUSED,
00700                                                       gpointer      marshal_data)
00701 {
00702   typedef gboolean (*GMarshalFunc_BOOLEAN__UINT_POINTER) (gpointer     data1,
00703                                                           guint        arg_1,
00704                                                           gpointer     arg_2,
00705                                                           gpointer     data2);
00706   register GMarshalFunc_BOOLEAN__UINT_POINTER callback;
00707   register GCClosure *cc = (GCClosure*) closure;
00708   register gpointer data1, data2;
00709   gboolean v_return;
00710 
00711   g_return_if_fail (return_value != NULL);
00712   g_return_if_fail (n_param_values == 3);
00713 
00714   if (G_CCLOSURE_SWAP_DATA (closure))
00715     {
00716       data1 = closure->data;
00717       data2 = g_value_peek_pointer (param_values + 0);
00718     }
00719   else
00720     {
00721       data1 = g_value_peek_pointer (param_values + 0);
00722       data2 = closure->data;
00723     }
00724   callback = (GMarshalFunc_BOOLEAN__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
00725 
00726   v_return = callback (data1,
00727                        g_marshal_value_peek_uint (param_values + 1),
00728                        g_marshal_value_peek_pointer (param_values + 2),
00729                        data2);
00730 
00731   g_value_set_boolean (return_value, v_return);
00732 }
00733 
00734 /* BOOLEAN:POINTER,POINTER,POINTER */
00735 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_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__POINTER_POINTER_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__POINTER_POINTER_POINTER) (gpointer     data1,
00750                                                                      gpointer     arg_1,
00751                                                                      gpointer     arg_2,
00752                                                                      gpointer     arg_3,
00753                                                                      gpointer     data2);
00754   register GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER callback;
00755   register GCClosure *cc = (GCClosure*) closure;
00756   register gpointer data1, data2;
00757   gboolean v_return;
00758 
00759   g_return_if_fail (return_value != NULL);
00760   g_return_if_fail (n_param_values == 4);
00761 
00762   if (G_CCLOSURE_SWAP_DATA (closure))
00763     {
00764       data1 = closure->data;
00765       data2 = g_value_peek_pointer (param_values + 0);
00766     }
00767   else
00768     {
00769       data1 = g_value_peek_pointer (param_values + 0);
00770       data2 = closure->data;
00771     }
00772   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00773 
00774   v_return = callback (data1,
00775                        g_marshal_value_peek_pointer (param_values + 1),
00776                        g_marshal_value_peek_pointer (param_values + 2),
00777                        g_marshal_value_peek_pointer (param_values + 3),
00778                        data2);
00779 
00780   g_value_set_boolean (return_value, v_return);
00781 }
00782 
00783 /* BOOLEAN:STRING,POINTER */
00784 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER (GClosure     *closure,
00785                                                                     GValue       *return_value,
00786                                                                     guint         n_param_values,
00787                                                                     const GValue *param_values,
00788                                                                     gpointer      invocation_hint,
00789                                                                     gpointer      marshal_data);
00790 void
00791 dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER (GClosure     *closure,
00792                                                         GValue       *return_value G_GNUC_UNUSED,
00793                                                         guint         n_param_values,
00794                                                         const GValue *param_values,
00795                                                         gpointer      invocation_hint G_GNUC_UNUSED,
00796                                                         gpointer      marshal_data)
00797 {
00798   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_POINTER) (gpointer     data1,
00799                                                             gpointer     arg_1,
00800                                                             gpointer     arg_2,
00801                                                             gpointer     data2);
00802   register GMarshalFunc_BOOLEAN__STRING_POINTER callback;
00803   register GCClosure *cc = (GCClosure*) closure;
00804   register gpointer data1, data2;
00805   gboolean v_return;
00806 
00807   g_return_if_fail (return_value != NULL);
00808   g_return_if_fail (n_param_values == 3);
00809 
00810   if (G_CCLOSURE_SWAP_DATA (closure))
00811     {
00812       data1 = closure->data;
00813       data2 = g_value_peek_pointer (param_values + 0);
00814     }
00815   else
00816     {
00817       data1 = g_value_peek_pointer (param_values + 0);
00818       data2 = closure->data;
00819     }
00820   callback = (GMarshalFunc_BOOLEAN__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
00821 
00822   v_return = callback (data1,
00823                        g_marshal_value_peek_string (param_values + 1),
00824                        g_marshal_value_peek_pointer (param_values + 2),
00825                        data2);
00826 
00827   g_value_set_boolean (return_value, v_return);
00828 }
00829 
00830 /* BOOLEAN:POINTER,POINTER */
00831 extern void dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_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__POINTER_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__POINTER_POINTER) (gpointer     data1,
00846                                                              gpointer     arg_1,
00847                                                              gpointer     arg_2,
00848                                                              gpointer     data2);
00849   register GMarshalFunc_BOOLEAN__POINTER_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__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
00868 
00869   v_return = callback (data1,
00870                        g_marshal_value_peek_pointer (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_equalizer_visible, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 211 },
00889   { (GCallback) audacious_rc_show_equalizer, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 270 },
00890   { (GCallback) audacious_rc_playlist_visible, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 317 },
00891   { (GCallback) audacious_rc_show_playlist, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 375 },
00892   { (GCallback) audacious_rc_get_tuple_fields, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 421 },
00893   { (GCallback) audacious_rc_play, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 476 },
00894   { (GCallback) audacious_rc_pause, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 505 },
00895   { (GCallback) audacious_rc_stop, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 535 },
00896   { (GCallback) audacious_rc_playing, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 564 },
00897   { (GCallback) audacious_rc_paused, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 615 },
00898   { (GCallback) audacious_rc_stopped, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 664 },
00899   { (GCallback) audacious_rc_status, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 715 },
00900   { (GCallback) audacious_rc_info, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER, 761 },
00901   { (GCallback) audacious_rc_time, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 828 },
00902   { (GCallback) audacious_rc_seek, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 870 },
00903   { (GCallback) audacious_rc_volume, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER, 907 },
00904   { (GCallback) audacious_rc_set_volume, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_INT_POINTER, 960 },
00905   { (GCallback) audacious_rc_balance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1008 },
00906   { (GCallback) audacious_rc_position, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1056 },
00907   { (GCallback) audacious_rc_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1101 },
00908   { (GCallback) audacious_rc_reverse, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1133 },
00909   { (GCallback) audacious_rc_length, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1165 },
00910   { (GCallback) audacious_rc_song_title, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1211 },
00911   { (GCallback) audacious_rc_song_filename, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1267 },
00912   { (GCallback) audacious_rc_song_length, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1329 },
00913   { (GCallback) audacious_rc_song_frames, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 1387 },
00914   { (GCallback) audacious_rc_song_tuple, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_STRING_POINTER_POINTER, 1445 },
00915   { (GCallback) audacious_rc_jump, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 1511 },
00916   { (GCallback) audacious_rc_add, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 1548 },
00917   { (GCallback) audacious_rc_add_url, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 1585 },
00918   { (GCallback) audacious_rc_add_list, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1624 },
00919   { (GCallback) audacious_rc_open_list, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1671 },
00920   { (GCallback) audacious_rc_open_list_to_temp, dbus_glib_marshal_audacious_rc_BOOLEAN__BOXED_POINTER, 1719 },
00921   { (GCallback) audacious_rc_delete, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER, 1773 },
00922   { (GCallback) audacious_rc_clear, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1812 },
00923   { (GCallback) audacious_rc_auto_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1842 },
00924   { (GCallback) audacious_rc_toggle_auto_advance, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1897 },
00925   { (GCallback) audacious_rc_repeat, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 1939 },
00926   { (GCallback) audacious_rc_toggle_repeat, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 1988 },
00927   { (GCallback) audacious_rc_shuffle, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 2025 },
00928   { (GCallback) audacious_rc_toggle_shuffle, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2076 },
00929   { (GCallback) audacious_rc_show_prefs_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2114 },
00930   { (GCallback) audacious_rc_show_about_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2160 },
00931   { (GCallback) audacious_rc_show_jtf_box, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2206 },
00932   { (GCallback) audacious_rc_show_filebrowser, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2250 },
00933   { (GCallback) audacious_rc_play_pause, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2299 },
00934   { (GCallback) audacious_rc_activate, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2333 },
00935   { (GCallback) audacious_rc_queue_get_list_pos, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 2366 },
00936   { (GCallback) audacious_rc_queue_get_queue_pos, dbus_glib_marshal_audacious_rc_BOOLEAN__UINT_POINTER_POINTER, 2427 },
00937   { (GCallback) audacious_rc_get_info, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER_POINTER, 2489 },
00938   { (GCallback) audacious_rc_toggle_aot, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 2559 },
00939   { (GCallback) audacious_rc_get_playqueue_length, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 2603 },
00940   { (GCallback) audacious_rc_playlist_ins_url_string, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_INT_POINTER, 2661 },
00941   { (GCallback) audacious_rc_playlist_add, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 2722 },
00942   { (GCallback) audacious_rc_playqueue_add, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER, 2767 },
00943   { (GCallback) audacious_rc_playqueue_remove, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER, 2812 },
00944   { (GCallback) audacious_rc_playqueue_clear, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER, 2860 },
00945   { (GCallback) audacious_rc_playqueue_is_queued, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER, 2899 },
00946   { (GCallback) audacious_rc_playlist_enqueue_to_temp, dbus_glib_marshal_audacious_rc_BOOLEAN__STRING_POINTER, 2967 },
00947   { (GCallback) audacious_rc_get_eq, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER_POINTER, 3021 },
00948   { (GCallback) audacious_rc_get_eq_preamp, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 3081 },
00949   { (GCallback) audacious_rc_get_eq_band, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_POINTER_POINTER, 3132 },
00950   { (GCallback) audacious_rc_set_eq, dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_BOXED_POINTER, 3189 },
00951   { (GCallback) audacious_rc_set_eq_preamp, dbus_glib_marshal_audacious_rc_BOOLEAN__DOUBLE_POINTER, 3241 },
00952   { (GCallback) audacious_rc_set_eq_band, dbus_glib_marshal_audacious_rc_BOOLEAN__INT_DOUBLE_POINTER, 3288 },
00953   { (GCallback) audacious_rc_equalizer_activate, dbus_glib_marshal_audacious_rc_BOOLEAN__BOOLEAN_POINTER, 3341 },
00954   { (GCallback) audacious_rc_get_active_playlist_name, dbus_glib_marshal_audacious_rc_BOOLEAN__POINTER_POINTER, 3394 },
00955 };
00956 
00957 const DBusGObjectInfo dbus_glib_audacious_rc_object_info = {
00958   0,
00959   dbus_glib_audacious_rc_methods,
00960   72,
00961 "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\0EqualizerVisible\0S\0is_eq_win\0O\0F\0N\0b\0\0org.atheme.audacious\0ShowEqualizer\0S\0show\0I\0b\0\0org.atheme.audacious\0PlaylistVisible\0S\0is_pl_win\0O\0F\0N\0b\0\0org.atheme.audacious\0ShowPlaylist\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\0Activate\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",
00962 "\0",
00963 "\0"
00964 };
00965 
00966 /* Generated by dbus-binding-tool; do not edit! */
00967 
00968 
00969 #ifndef __dbus_glib_marshal_mpris_root_MARSHAL_H__
00970 #define __dbus_glib_marshal_mpris_root_MARSHAL_H__
00971 
00972 #include        <glib-object.h>
00973 
00974 G_BEGIN_DECLS
00975 
00976 #ifdef G_ENABLE_DEBUG
00977 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
00978 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
00979 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
00980 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
00981 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
00982 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
00983 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
00984 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
00985 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
00986 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
00987 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
00988 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
00989 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
00990 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
00991 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
00992 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
00993 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
00994 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
00995 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
00996 #else /* !G_ENABLE_DEBUG */
00997 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
00998  *          Do not access GValues directly in your code. Instead, use the
00999  *          g_value_get_*() functions
01000  */
01001 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
01002 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
01003 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
01004 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
01005 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01006 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01007 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01008 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01009 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01010 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01011 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01012 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01013 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01014 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01015 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01016 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01017 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01018 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01019 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01020 #endif /* !G_ENABLE_DEBUG */
01021 
01022 
01023 /* BOOLEAN:POINTER */
01024 extern void dbus_glib_marshal_mpris_root_BOOLEAN__POINTER (GClosure     *closure,
01025                                                            GValue       *return_value,
01026                                                            guint         n_param_values,
01027                                                            const GValue *param_values,
01028                                                            gpointer      invocation_hint,
01029                                                            gpointer      marshal_data);
01030 void
01031 dbus_glib_marshal_mpris_root_BOOLEAN__POINTER (GClosure     *closure,
01032                                                GValue       *return_value G_GNUC_UNUSED,
01033                                                guint         n_param_values,
01034                                                const GValue *param_values,
01035                                                gpointer      invocation_hint G_GNUC_UNUSED,
01036                                                gpointer      marshal_data)
01037 {
01038   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
01039                                                      gpointer     arg_1,
01040                                                      gpointer     data2);
01041   register GMarshalFunc_BOOLEAN__POINTER callback;
01042   register GCClosure *cc = (GCClosure*) closure;
01043   register gpointer data1, data2;
01044   gboolean v_return;
01045 
01046   g_return_if_fail (return_value != NULL);
01047   g_return_if_fail (n_param_values == 2);
01048 
01049   if (G_CCLOSURE_SWAP_DATA (closure))
01050     {
01051       data1 = closure->data;
01052       data2 = g_value_peek_pointer (param_values + 0);
01053     }
01054   else
01055     {
01056       data1 = g_value_peek_pointer (param_values + 0);
01057       data2 = closure->data;
01058     }
01059   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
01060 
01061   v_return = callback (data1,
01062                        g_marshal_value_peek_pointer (param_values + 1),
01063                        data2);
01064 
01065   g_value_set_boolean (return_value, v_return);
01066 }
01067 
01068 /* BOOLEAN:POINTER,POINTER */
01069 extern void dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01070                                                                    GValue       *return_value,
01071                                                                    guint         n_param_values,
01072                                                                    const GValue *param_values,
01073                                                                    gpointer      invocation_hint,
01074                                                                    gpointer      marshal_data);
01075 void
01076 dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01077                                                        GValue       *return_value G_GNUC_UNUSED,
01078                                                        guint         n_param_values,
01079                                                        const GValue *param_values,
01080                                                        gpointer      invocation_hint G_GNUC_UNUSED,
01081                                                        gpointer      marshal_data)
01082 {
01083   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01084                                                              gpointer     arg_1,
01085                                                              gpointer     arg_2,
01086                                                              gpointer     data2);
01087   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01088   register GCClosure *cc = (GCClosure*) closure;
01089   register gpointer data1, data2;
01090   gboolean v_return;
01091 
01092   g_return_if_fail (return_value != NULL);
01093   g_return_if_fail (n_param_values == 3);
01094 
01095   if (G_CCLOSURE_SWAP_DATA (closure))
01096     {
01097       data1 = closure->data;
01098       data2 = g_value_peek_pointer (param_values + 0);
01099     }
01100   else
01101     {
01102       data1 = g_value_peek_pointer (param_values + 0);
01103       data2 = closure->data;
01104     }
01105   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01106 
01107   v_return = callback (data1,
01108                        g_marshal_value_peek_pointer (param_values + 1),
01109                        g_marshal_value_peek_pointer (param_values + 2),
01110                        data2);
01111 
01112   g_value_set_boolean (return_value, v_return);
01113 }
01114 
01115 G_END_DECLS
01116 
01117 #endif /* __dbus_glib_marshal_mpris_root_MARSHAL_H__ */
01118 
01119 #include <dbus/dbus-glib.h>
01120 static const DBusGMethodInfo dbus_glib_mpris_root_methods[] = {
01121   { (GCallback) mpris_root_identity, dbus_glib_marshal_mpris_root_BOOLEAN__POINTER_POINTER, 0 },
01122   { (GCallback) mpris_root_quit, dbus_glib_marshal_mpris_root_BOOLEAN__POINTER, 53 },
01123 };
01124 
01125 const DBusGObjectInfo dbus_glib_mpris_root_object_info = {
01126   0,
01127   dbus_glib_mpris_root_methods,
01128   2,
01129 "org.freedesktop.MediaPlayer\0Identity\0S\0arg0\0O\0F\0N\0s\0\0org.freedesktop.MediaPlayer\0Quit\0S\0\0\0",
01130 "\0",
01131 "\0"
01132 };
01133 
01134 /* Generated by dbus-binding-tool; do not edit! */
01135 
01136 
01137 #ifndef __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__
01138 #define __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__
01139 
01140 #include        <glib-object.h>
01141 
01142 G_BEGIN_DECLS
01143 
01144 #ifdef G_ENABLE_DEBUG
01145 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
01146 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
01147 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
01148 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
01149 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
01150 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
01151 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
01152 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
01153 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
01154 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
01155 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
01156 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
01157 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
01158 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
01159 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
01160 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
01161 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
01162 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
01163 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
01164 #else /* !G_ENABLE_DEBUG */
01165 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
01166  *          Do not access GValues directly in your code. Instead, use the
01167  *          g_value_get_*() functions
01168  */
01169 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
01170 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
01171 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
01172 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
01173 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01174 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01175 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01176 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01177 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01178 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01179 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01180 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01181 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01182 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01183 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01184 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01185 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01186 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01187 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01188 #endif /* !G_ENABLE_DEBUG */
01189 
01190 
01191 /* BOOLEAN:INT,POINTER,POINTER */
01192 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
01193                                                                             GValue       *return_value,
01194                                                                             guint         n_param_values,
01195                                                                             const GValue *param_values,
01196                                                                             gpointer      invocation_hint,
01197                                                                             gpointer      marshal_data);
01198 void
01199 dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER (GClosure     *closure,
01200                                                                 GValue       *return_value G_GNUC_UNUSED,
01201                                                                 guint         n_param_values,
01202                                                                 const GValue *param_values,
01203                                                                 gpointer      invocation_hint G_GNUC_UNUSED,
01204                                                                 gpointer      marshal_data)
01205 {
01206   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (gpointer     data1,
01207                                                                  gint         arg_1,
01208                                                                  gpointer     arg_2,
01209                                                                  gpointer     arg_3,
01210                                                                  gpointer     data2);
01211   register GMarshalFunc_BOOLEAN__INT_POINTER_POINTER callback;
01212   register GCClosure *cc = (GCClosure*) closure;
01213   register gpointer data1, data2;
01214   gboolean v_return;
01215 
01216   g_return_if_fail (return_value != NULL);
01217   g_return_if_fail (n_param_values == 4);
01218 
01219   if (G_CCLOSURE_SWAP_DATA (closure))
01220     {
01221       data1 = closure->data;
01222       data2 = g_value_peek_pointer (param_values + 0);
01223     }
01224   else
01225     {
01226       data1 = g_value_peek_pointer (param_values + 0);
01227       data2 = closure->data;
01228     }
01229   callback = (GMarshalFunc_BOOLEAN__INT_POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01230 
01231   v_return = callback (data1,
01232                        g_marshal_value_peek_int (param_values + 1),
01233                        g_marshal_value_peek_pointer (param_values + 2),
01234                        g_marshal_value_peek_pointer (param_values + 3),
01235                        data2);
01236 
01237   g_value_set_boolean (return_value, v_return);
01238 }
01239 
01240 /* BOOLEAN:STRING,BOOLEAN,POINTER */
01241 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER (GClosure     *closure,
01242                                                                                GValue       *return_value,
01243                                                                                guint         n_param_values,
01244                                                                                const GValue *param_values,
01245                                                                                gpointer      invocation_hint,
01246                                                                                gpointer      marshal_data);
01247 void
01248 dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER (GClosure     *closure,
01249                                                                    GValue       *return_value G_GNUC_UNUSED,
01250                                                                    guint         n_param_values,
01251                                                                    const GValue *param_values,
01252                                                                    gpointer      invocation_hint G_GNUC_UNUSED,
01253                                                                    gpointer      marshal_data)
01254 {
01255   typedef gboolean (*GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER) (gpointer     data1,
01256                                                                     gpointer     arg_1,
01257                                                                     gboolean     arg_2,
01258                                                                     gpointer     arg_3,
01259                                                                     gpointer     data2);
01260   register GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER callback;
01261   register GCClosure *cc = (GCClosure*) closure;
01262   register gpointer data1, data2;
01263   gboolean v_return;
01264 
01265   g_return_if_fail (return_value != NULL);
01266   g_return_if_fail (n_param_values == 4);
01267 
01268   if (G_CCLOSURE_SWAP_DATA (closure))
01269     {
01270       data1 = closure->data;
01271       data2 = g_value_peek_pointer (param_values + 0);
01272     }
01273   else
01274     {
01275       data1 = g_value_peek_pointer (param_values + 0);
01276       data2 = closure->data;
01277     }
01278   callback = (GMarshalFunc_BOOLEAN__STRING_BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01279 
01280   v_return = callback (data1,
01281                        g_marshal_value_peek_string (param_values + 1),
01282                        g_marshal_value_peek_boolean (param_values + 2),
01283                        g_marshal_value_peek_pointer (param_values + 3),
01284                        data2);
01285 
01286   g_value_set_boolean (return_value, v_return);
01287 }
01288 
01289 /* BOOLEAN:INT,POINTER */
01290 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER (GClosure     *closure,
01291                                                                     GValue       *return_value,
01292                                                                     guint         n_param_values,
01293                                                                     const GValue *param_values,
01294                                                                     gpointer      invocation_hint,
01295                                                                     gpointer      marshal_data);
01296 void
01297 dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER (GClosure     *closure,
01298                                                         GValue       *return_value G_GNUC_UNUSED,
01299                                                         guint         n_param_values,
01300                                                         const GValue *param_values,
01301                                                         gpointer      invocation_hint G_GNUC_UNUSED,
01302                                                         gpointer      marshal_data)
01303 {
01304   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER) (gpointer     data1,
01305                                                          gint         arg_1,
01306                                                          gpointer     arg_2,
01307                                                          gpointer     data2);
01308   register GMarshalFunc_BOOLEAN__INT_POINTER callback;
01309   register GCClosure *cc = (GCClosure*) closure;
01310   register gpointer data1, data2;
01311   gboolean v_return;
01312 
01313   g_return_if_fail (return_value != NULL);
01314   g_return_if_fail (n_param_values == 3);
01315 
01316   if (G_CCLOSURE_SWAP_DATA (closure))
01317     {
01318       data1 = closure->data;
01319       data2 = g_value_peek_pointer (param_values + 0);
01320     }
01321   else
01322     {
01323       data1 = g_value_peek_pointer (param_values + 0);
01324       data2 = closure->data;
01325     }
01326   callback = (GMarshalFunc_BOOLEAN__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
01327 
01328   v_return = callback (data1,
01329                        g_marshal_value_peek_int (param_values + 1),
01330                        g_marshal_value_peek_pointer (param_values + 2),
01331                        data2);
01332 
01333   g_value_set_boolean (return_value, v_return);
01334 }
01335 
01336 /* BOOLEAN:BOOLEAN,POINTER */
01337 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01338                                                                         GValue       *return_value,
01339                                                                         guint         n_param_values,
01340                                                                         const GValue *param_values,
01341                                                                         gpointer      invocation_hint,
01342                                                                         gpointer      marshal_data);
01343 void
01344 dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01345                                                             GValue       *return_value G_GNUC_UNUSED,
01346                                                             guint         n_param_values,
01347                                                             const GValue *param_values,
01348                                                             gpointer      invocation_hint G_GNUC_UNUSED,
01349                                                             gpointer      marshal_data)
01350 {
01351   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
01352                                                              gboolean     arg_1,
01353                                                              gpointer     arg_2,
01354                                                              gpointer     data2);
01355   register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
01356   register GCClosure *cc = (GCClosure*) closure;
01357   register gpointer data1, data2;
01358   gboolean v_return;
01359 
01360   g_return_if_fail (return_value != NULL);
01361   g_return_if_fail (n_param_values == 3);
01362 
01363   if (G_CCLOSURE_SWAP_DATA (closure))
01364     {
01365       data1 = closure->data;
01366       data2 = g_value_peek_pointer (param_values + 0);
01367     }
01368   else
01369     {
01370       data1 = g_value_peek_pointer (param_values + 0);
01371       data2 = closure->data;
01372     }
01373   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01374 
01375   v_return = callback (data1,
01376                        g_marshal_value_peek_boolean (param_values + 1),
01377                        g_marshal_value_peek_pointer (param_values + 2),
01378                        data2);
01379 
01380   g_value_set_boolean (return_value, v_return);
01381 }
01382 
01383 /* BOOLEAN:POINTER,POINTER */
01384 extern void dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01385                                                                         GValue       *return_value,
01386                                                                         guint         n_param_values,
01387                                                                         const GValue *param_values,
01388                                                                         gpointer      invocation_hint,
01389                                                                         gpointer      marshal_data);
01390 void
01391 dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01392                                                             GValue       *return_value G_GNUC_UNUSED,
01393                                                             guint         n_param_values,
01394                                                             const GValue *param_values,
01395                                                             gpointer      invocation_hint G_GNUC_UNUSED,
01396                                                             gpointer      marshal_data)
01397 {
01398   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01399                                                              gpointer     arg_1,
01400                                                              gpointer     arg_2,
01401                                                              gpointer     data2);
01402   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01403   register GCClosure *cc = (GCClosure*) closure;
01404   register gpointer data1, data2;
01405   gboolean v_return;
01406 
01407   g_return_if_fail (return_value != NULL);
01408   g_return_if_fail (n_param_values == 3);
01409 
01410   if (G_CCLOSURE_SWAP_DATA (closure))
01411     {
01412       data1 = closure->data;
01413       data2 = g_value_peek_pointer (param_values + 0);
01414     }
01415   else
01416     {
01417       data1 = g_value_peek_pointer (param_values + 0);
01418       data2 = closure->data;
01419     }
01420   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01421 
01422   v_return = callback (data1,
01423                        g_marshal_value_peek_pointer (param_values + 1),
01424                        g_marshal_value_peek_pointer (param_values + 2),
01425                        data2);
01426 
01427   g_value_set_boolean (return_value, v_return);
01428 }
01429 
01430 G_END_DECLS
01431 
01432 #endif /* __dbus_glib_marshal_mpris_tracklist_MARSHAL_H__ */
01433 
01434 #include <dbus/dbus-glib.h>
01435 static const DBusGMethodInfo dbus_glib_mpris_tracklist_methods[] = {
01436   { (GCallback) mpris_tracklist_get_metadata, dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER_POINTER, 0 },
01437   { (GCallback) mpris_tracklist_get_current_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER, 69 },
01438   { (GCallback) mpris_tracklist_get_length, dbus_glib_marshal_mpris_tracklist_BOOLEAN__POINTER_POINTER, 129 },
01439   { (GCallback) mpris_tracklist_add_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__STRING_BOOLEAN_POINTER, 183 },
01440   { (GCallback) mpris_tracklist_del_track, dbus_glib_marshal_mpris_tracklist_BOOLEAN__INT_POINTER, 241 },
01441   { (GCallback) mpris_tracklist_loop, dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER, 290 },
01442   { (GCallback) mpris_tracklist_random, dbus_glib_marshal_mpris_tracklist_BOOLEAN__BOOLEAN_POINTER, 335 },
01443 };
01444 
01445 const DBusGObjectInfo dbus_glib_mpris_tracklist_object_info = {
01446   0,
01447   dbus_glib_mpris_tracklist_methods,
01448   7,
01449 "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",
01450 "org.freedesktop.MediaPlayer\0TrackListChange\0\0",
01451 "\0"
01452 };
01453 
01454 /* Generated by dbus-binding-tool; do not edit! */
01455 
01456 
01457 #ifndef __dbus_glib_marshal_mpris_player_MARSHAL_H__
01458 #define __dbus_glib_marshal_mpris_player_MARSHAL_H__
01459 
01460 #include        <glib-object.h>
01461 
01462 G_BEGIN_DECLS
01463 
01464 #ifdef G_ENABLE_DEBUG
01465 #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
01466 #define g_marshal_value_peek_char(v)     g_value_get_char (v)
01467 #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
01468 #define g_marshal_value_peek_int(v)      g_value_get_int (v)
01469 #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
01470 #define g_marshal_value_peek_long(v)     g_value_get_long (v)
01471 #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
01472 #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
01473 #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
01474 #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
01475 #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
01476 #define g_marshal_value_peek_float(v)    g_value_get_float (v)
01477 #define g_marshal_value_peek_double(v)   g_value_get_double (v)
01478 #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
01479 #define g_marshal_value_peek_param(v)    g_value_get_param (v)
01480 #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
01481 #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
01482 #define g_marshal_value_peek_object(v)   g_value_get_object (v)
01483 #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
01484 #else /* !G_ENABLE_DEBUG */
01485 /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
01486  *          Do not access GValues directly in your code. Instead, use the
01487  *          g_value_get_*() functions
01488  */
01489 #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
01490 #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
01491 #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
01492 #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
01493 #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
01494 #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
01495 #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
01496 #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
01497 #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
01498 #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
01499 #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
01500 #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
01501 #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
01502 #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
01503 #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
01504 #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
01505 #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
01506 #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
01507 #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
01508 #endif /* !G_ENABLE_DEBUG */
01509 
01510 
01511 /* BOOLEAN:POINTER */
01512 extern void dbus_glib_marshal_mpris_player_BOOLEAN__POINTER (GClosure     *closure,
01513                                                              GValue       *return_value,
01514                                                              guint         n_param_values,
01515                                                              const GValue *param_values,
01516                                                              gpointer      invocation_hint,
01517                                                              gpointer      marshal_data);
01518 void
01519 dbus_glib_marshal_mpris_player_BOOLEAN__POINTER (GClosure     *closure,
01520                                                  GValue       *return_value G_GNUC_UNUSED,
01521                                                  guint         n_param_values,
01522                                                  const GValue *param_values,
01523                                                  gpointer      invocation_hint G_GNUC_UNUSED,
01524                                                  gpointer      marshal_data)
01525 {
01526   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER) (gpointer     data1,
01527                                                      gpointer     arg_1,
01528                                                      gpointer     data2);
01529   register GMarshalFunc_BOOLEAN__POINTER callback;
01530   register GCClosure *cc = (GCClosure*) closure;
01531   register gpointer data1, data2;
01532   gboolean v_return;
01533 
01534   g_return_if_fail (return_value != NULL);
01535   g_return_if_fail (n_param_values == 2);
01536 
01537   if (G_CCLOSURE_SWAP_DATA (closure))
01538     {
01539       data1 = closure->data;
01540       data2 = g_value_peek_pointer (param_values + 0);
01541     }
01542   else
01543     {
01544       data1 = g_value_peek_pointer (param_values + 0);
01545       data2 = closure->data;
01546     }
01547   callback = (GMarshalFunc_BOOLEAN__POINTER) (marshal_data ? marshal_data : cc->callback);
01548 
01549   v_return = callback (data1,
01550                        g_marshal_value_peek_pointer (param_values + 1),
01551                        data2);
01552 
01553   g_value_set_boolean (return_value, v_return);
01554 }
01555 
01556 /* BOOLEAN:BOOLEAN,POINTER */
01557 extern void dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01558                                                                      GValue       *return_value,
01559                                                                      guint         n_param_values,
01560                                                                      const GValue *param_values,
01561                                                                      gpointer      invocation_hint,
01562                                                                      gpointer      marshal_data);
01563 void
01564 dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER (GClosure     *closure,
01565                                                          GValue       *return_value G_GNUC_UNUSED,
01566                                                          guint         n_param_values,
01567                                                          const GValue *param_values,
01568                                                          gpointer      invocation_hint G_GNUC_UNUSED,
01569                                                          gpointer      marshal_data)
01570 {
01571   typedef gboolean (*GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (gpointer     data1,
01572                                                              gboolean     arg_1,
01573                                                              gpointer     arg_2,
01574                                                              gpointer     data2);
01575   register GMarshalFunc_BOOLEAN__BOOLEAN_POINTER callback;
01576   register GCClosure *cc = (GCClosure*) closure;
01577   register gpointer data1, data2;
01578   gboolean v_return;
01579 
01580   g_return_if_fail (return_value != NULL);
01581   g_return_if_fail (n_param_values == 3);
01582 
01583   if (G_CCLOSURE_SWAP_DATA (closure))
01584     {
01585       data1 = closure->data;
01586       data2 = g_value_peek_pointer (param_values + 0);
01587     }
01588   else
01589     {
01590       data1 = g_value_peek_pointer (param_values + 0);
01591       data2 = closure->data;
01592     }
01593   callback = (GMarshalFunc_BOOLEAN__BOOLEAN_POINTER) (marshal_data ? marshal_data : cc->callback);
01594 
01595   v_return = callback (data1,
01596                        g_marshal_value_peek_boolean (param_values + 1),
01597                        g_marshal_value_peek_pointer (param_values + 2),
01598                        data2);
01599 
01600   g_value_set_boolean (return_value, v_return);
01601 }
01602 
01603 /* BOOLEAN:POINTER,POINTER */
01604 extern void dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01605                                                                      GValue       *return_value,
01606                                                                      guint         n_param_values,
01607                                                                      const GValue *param_values,
01608                                                                      gpointer      invocation_hint,
01609                                                                      gpointer      marshal_data);
01610 void
01611 dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER (GClosure     *closure,
01612                                                          GValue       *return_value G_GNUC_UNUSED,
01613                                                          guint         n_param_values,
01614                                                          const GValue *param_values,
01615                                                          gpointer      invocation_hint G_GNUC_UNUSED,
01616                                                          gpointer      marshal_data)
01617 {
01618   typedef gboolean (*GMarshalFunc_BOOLEAN__POINTER_POINTER) (gpointer     data1,
01619                                                              gpointer     arg_1,
01620                                                              gpointer     arg_2,
01621                                                              gpointer     data2);
01622   register GMarshalFunc_BOOLEAN__POINTER_POINTER callback;
01623   register GCClosure *cc = (GCClosure*) closure;
01624   register gpointer data1, data2;
01625   gboolean v_return;
01626 
01627   g_return_if_fail (return_value != NULL);
01628   g_return_if_fail (n_param_values == 3);
01629 
01630   if (G_CCLOSURE_SWAP_DATA (closure))
01631     {
01632       data1 = closure->data;
01633       data2 = g_value_peek_pointer (param_values + 0);
01634     }
01635   else
01636     {
01637       data1 = g_value_peek_pointer (param_values + 0);
01638       data2 = closure->data;
01639     }
01640   callback = (GMarshalFunc_BOOLEAN__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
01641 
01642   v_return = callback (data1,
01643                        g_marshal_value_peek_pointer (param_values + 1),
01644                        g_marshal_value_peek_pointer (param_values + 2),
01645                        data2);
01646 
01647   g_value_set_boolean (return_value, v_return);
01648 }
01649 
01650 /* BOOLEAN:INT,POINTER */
01651 extern void dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER (GClosure     *closure,
01652                                                                  GValue       *return_value,
01653                                                                  guint         n_param_values,
01654                                                                  const GValue *param_values,
01655                                                                  gpointer      invocation_hint,
01656                                                                  gpointer      marshal_data);
01657 void
01658 dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER (GClosure     *closure,
01659                                                      GValue       *return_value G_GNUC_UNUSED,
01660                                                      guint         n_param_values,
01661                                                      const GValue *param_values,
01662                                                      gpointer      invocation_hint G_GNUC_UNUSED,
01663                                                      gpointer      marshal_data)
01664 {
01665   typedef gboolean (*GMarshalFunc_BOOLEAN__INT_POINTER) (gpointer     data1,
01666                                                          gint         arg_1,
01667                                                          gpointer     arg_2,
01668                                                          gpointer     data2);
01669   register GMarshalFunc_BOOLEAN__INT_POINTER callback;
01670   register GCClosure *cc = (GCClosure*) closure;
01671   register gpointer data1, data2;
01672   gboolean v_return;
01673 
01674   g_return_if_fail (return_value != NULL);
01675   g_return_if_fail (n_param_values == 3);
01676 
01677   if (G_CCLOSURE_SWAP_DATA (closure))
01678     {
01679       data1 = closure->data;
01680       data2 = g_value_peek_pointer (param_values + 0);
01681     }
01682   else
01683     {
01684       data1 = g_value_peek_pointer (param_values + 0);
01685       data2 = closure->data;
01686     }
01687   callback = (GMarshalFunc_BOOLEAN__INT_POINTER) (marshal_data ? marshal_data : cc->callback);
01688 
01689   v_return = callback (data1,
01690                        g_marshal_value_peek_int (param_values + 1),
01691                        g_marshal_value_peek_pointer (param_values + 2),
01692                        data2);
01693 
01694   g_value_set_boolean (return_value, v_return);
01695 }
01696 
01697 G_END_DECLS
01698 
01699 #endif /* __dbus_glib_marshal_mpris_player_MARSHAL_H__ */
01700 
01701 #include <dbus/dbus-glib.h>
01702 static const DBusGMethodInfo dbus_glib_mpris_player_methods[] = {
01703   { (GCallback) mpris_player_next, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 0 },
01704   { (GCallback) mpris_player_prev, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 36 },
01705   { (GCallback) mpris_player_pause, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 72 },
01706   { (GCallback) mpris_player_stop, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 109 },
01707   { (GCallback) mpris_player_play, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER, 145 },
01708   { (GCallback) mpris_player_repeat, dbus_glib_marshal_mpris_player_BOOLEAN__BOOLEAN_POINTER, 181 },
01709   { (GCallback) mpris_player_get_status, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 228 },
01710   { (GCallback) mpris_player_get_metadata, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 287 },
01711   { (GCallback) mpris_player_get_caps, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 347 },
01712   { (GCallback) mpris_player_volume_set, dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER, 399 },
01713   { (GCallback) mpris_player_volume_get, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 449 },
01714   { (GCallback) mpris_player_position_set, dbus_glib_marshal_mpris_player_BOOLEAN__INT_POINTER, 503 },
01715   { (GCallback) mpris_player_position_get, dbus_glib_marshal_mpris_player_BOOLEAN__POINTER_POINTER, 555 },
01716 };
01717 
01718 const DBusGObjectInfo dbus_glib_mpris_player_object_info = {
01719   0,
01720   dbus_glib_mpris_player_methods,
01721   13,
01722 "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",
01723 "org.freedesktop.MediaPlayer\0TrackChange\0org.freedesktop.MediaPlayer\0StatusChange\0org.freedesktop.MediaPlayer\0CapsChange\0\0",
01724 "\0"
01725 };
01726