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