1 

     2 /* Generated by dbus-binding-tool; do not edit! */

     3 

     4 #include <glib/gtypes.h>

     5 #include <glib/gerror.h>

     6 #include <dbus/dbus-glib.h>

     7 

     8 G_BEGIN_DECLS

     9 

    10 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    11 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    12 

    13 static

    14 #ifdef G_HAVE_INLINE

    15 inline

    16 #endif

    17 gboolean

    18 org_freedesktop_DBus_Introspectable_introspect (DBusGProxy *proxy, char ** OUT_data, GError **error)

    19 

    20 {

    21   return dbus_g_proxy_call (proxy, "Introspect", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_data, G_TYPE_INVALID);

    22 }

    23 

    24 typedef void (*org_freedesktop_DBus_Introspectable_introspect_reply) (DBusGProxy *proxy, char * OUT_data, GError *error, gpointer userdata);

    25 

    26 static void

    27 org_freedesktop_DBus_Introspectable_introspect_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

    28 {

    29   DBusGAsyncData *data = user_data;

    30   GError *error = NULL;

    31   char * OUT_data;

    32   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_data, G_TYPE_INVALID);

    33   (*(org_freedesktop_DBus_Introspectable_introspect_reply)data->cb) (proxy, OUT_data, error, data->userdata);

    34   return;

    35 }

    36 

    37 static

    38 #ifdef G_HAVE_INLINE

    39 inline

    40 #endif

    41 DBusGProxyCall*

    42 org_freedesktop_DBus_Introspectable_introspect_async (DBusGProxy *proxy, org_freedesktop_DBus_Introspectable_introspect_reply callback, gpointer userdata)

    43 

    44 {

    45   DBusGAsyncData *stuff;

    46   stuff = g_new (DBusGAsyncData, 1);

    47   stuff->cb = G_CALLBACK (callback);

    48   stuff->userdata = userdata;

    49   return dbus_g_proxy_begin_call (proxy, "Introspect", org_freedesktop_DBus_Introspectable_introspect_async_callback, stuff, g_free, G_TYPE_INVALID);

    50 }

    51 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable */

    52 

    53 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    54 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    55 

    56 static

    57 #ifdef G_HAVE_INLINE

    58 inline

    59 #endif

    60 gboolean

    61 org_freedesktop_DBus_request_name (DBusGProxy *proxy, const char * IN_arg0, const guint IN_arg1, guint* OUT_arg2, GError **error)

    62 

    63 {

    64   return dbus_g_proxy_call (proxy, "RequestName", error, G_TYPE_STRING, IN_arg0, G_TYPE_UINT, IN_arg1, G_TYPE_INVALID, G_TYPE_UINT, OUT_arg2, G_TYPE_INVALID);

    65 }

    66 

    67 typedef void (*org_freedesktop_DBus_request_name_reply) (DBusGProxy *proxy, guint OUT_arg2, GError *error, gpointer userdata);

    68 

    69 static void

    70 org_freedesktop_DBus_request_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

    71 {

    72   DBusGAsyncData *data = user_data;

    73   GError *error = NULL;

    74   guint OUT_arg2;

    75   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_arg2, G_TYPE_INVALID);

    76   (*(org_freedesktop_DBus_request_name_reply)data->cb) (proxy, OUT_arg2, error, data->userdata);

    77   return;

    78 }

    79 

    80 static

    81 #ifdef G_HAVE_INLINE

    82 inline

    83 #endif

    84 DBusGProxyCall*

    85 org_freedesktop_DBus_request_name_async (DBusGProxy *proxy, const char * IN_arg0, const guint IN_arg1, org_freedesktop_DBus_request_name_reply callback, gpointer userdata)

    86 

    87 {

    88   DBusGAsyncData *stuff;

    89   stuff = g_new (DBusGAsyncData, 1);

    90   stuff->cb = G_CALLBACK (callback);

    91   stuff->userdata = userdata;

    92   return dbus_g_proxy_begin_call (proxy, "RequestName", org_freedesktop_DBus_request_name_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_UINT, IN_arg1, G_TYPE_INVALID);

    93 }

    94 static

    95 #ifdef G_HAVE_INLINE

    96 inline

    97 #endif

    98 gboolean

    99 org_freedesktop_DBus_release_name (DBusGProxy *proxy, const char * IN_arg0, guint* OUT_arg1, GError **error)

   100 

   101 {

   102   return dbus_g_proxy_call (proxy, "ReleaseName", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_UINT, OUT_arg1, G_TYPE_INVALID);

   103 }

   104 

   105 typedef void (*org_freedesktop_DBus_release_name_reply) (DBusGProxy *proxy, guint OUT_arg1, GError *error, gpointer userdata);

   106 

   107 static void

   108 org_freedesktop_DBus_release_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   109 {

   110   DBusGAsyncData *data = user_data;

   111   GError *error = NULL;

   112   guint OUT_arg1;

   113   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_arg1, G_TYPE_INVALID);

   114   (*(org_freedesktop_DBus_release_name_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   115   return;

   116 }

   117 

   118 static

   119 #ifdef G_HAVE_INLINE

   120 inline

   121 #endif

   122 DBusGProxyCall*

   123 org_freedesktop_DBus_release_name_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_release_name_reply callback, gpointer userdata)

   124 

   125 {

   126   DBusGAsyncData *stuff;

   127   stuff = g_new (DBusGAsyncData, 1);

   128   stuff->cb = G_CALLBACK (callback);

   129   stuff->userdata = userdata;

   130   return dbus_g_proxy_begin_call (proxy, "ReleaseName", org_freedesktop_DBus_release_name_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   131 }

   132 static

   133 #ifdef G_HAVE_INLINE

   134 inline

   135 #endif

   136 gboolean

   137 org_freedesktop_DBus_start_service_by_name (DBusGProxy *proxy, const char * IN_arg0, const guint IN_arg1, guint* OUT_arg2, GError **error)

   138 

   139 {

   140   return dbus_g_proxy_call (proxy, "StartServiceByName", error, G_TYPE_STRING, IN_arg0, G_TYPE_UINT, IN_arg1, G_TYPE_INVALID, G_TYPE_UINT, OUT_arg2, G_TYPE_INVALID);

   141 }

   142 

   143 typedef void (*org_freedesktop_DBus_start_service_by_name_reply) (DBusGProxy *proxy, guint OUT_arg2, GError *error, gpointer userdata);

   144 

   145 static void

   146 org_freedesktop_DBus_start_service_by_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   147 {

   148   DBusGAsyncData *data = user_data;

   149   GError *error = NULL;

   150   guint OUT_arg2;

   151   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_arg2, G_TYPE_INVALID);

   152   (*(org_freedesktop_DBus_start_service_by_name_reply)data->cb) (proxy, OUT_arg2, error, data->userdata);

   153   return;

   154 }

   155 

   156 static

   157 #ifdef G_HAVE_INLINE

   158 inline

   159 #endif

   160 DBusGProxyCall*

   161 org_freedesktop_DBus_start_service_by_name_async (DBusGProxy *proxy, const char * IN_arg0, const guint IN_arg1, org_freedesktop_DBus_start_service_by_name_reply callback, gpointer userdata)

   162 

   163 {

   164   DBusGAsyncData *stuff;

   165   stuff = g_new (DBusGAsyncData, 1);

   166   stuff->cb = G_CALLBACK (callback);

   167   stuff->userdata = userdata;

   168   return dbus_g_proxy_begin_call (proxy, "StartServiceByName", org_freedesktop_DBus_start_service_by_name_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_UINT, IN_arg1, G_TYPE_INVALID);

   169 }

   170 static

   171 #ifdef G_HAVE_INLINE

   172 inline

   173 #endif

   174 gboolean

   175 org_freedesktop_DBus_hello (DBusGProxy *proxy, char ** OUT_arg0, GError **error)

   176 

   177 {

   178   return dbus_g_proxy_call (proxy, "Hello", error, G_TYPE_INVALID, G_TYPE_STRING, OUT_arg0, G_TYPE_INVALID);

   179 }

   180 

   181 typedef void (*org_freedesktop_DBus_hello_reply) (DBusGProxy *proxy, char * OUT_arg0, GError *error, gpointer userdata);

   182 

   183 static void

   184 org_freedesktop_DBus_hello_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   185 {

   186   DBusGAsyncData *data = user_data;

   187   GError *error = NULL;

   188   char * OUT_arg0;

   189   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_arg0, G_TYPE_INVALID);

   190   (*(org_freedesktop_DBus_hello_reply)data->cb) (proxy, OUT_arg0, error, data->userdata);

   191   return;

   192 }

   193 

   194 static

   195 #ifdef G_HAVE_INLINE

   196 inline

   197 #endif

   198 DBusGProxyCall*

   199 org_freedesktop_DBus_hello_async (DBusGProxy *proxy, org_freedesktop_DBus_hello_reply callback, gpointer userdata)

   200 

   201 {

   202   DBusGAsyncData *stuff;

   203   stuff = g_new (DBusGAsyncData, 1);

   204   stuff->cb = G_CALLBACK (callback);

   205   stuff->userdata = userdata;

   206   return dbus_g_proxy_begin_call (proxy, "Hello", org_freedesktop_DBus_hello_async_callback, stuff, g_free, G_TYPE_INVALID);

   207 }

   208 static

   209 #ifdef G_HAVE_INLINE

   210 inline

   211 #endif

   212 gboolean

   213 org_freedesktop_DBus_name_has_owner (DBusGProxy *proxy, const char * IN_arg0, gboolean* OUT_arg1, GError **error)

   214 

   215 {

   216   return dbus_g_proxy_call (proxy, "NameHasOwner", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_BOOLEAN, OUT_arg1, G_TYPE_INVALID);

   217 }

   218 

   219 typedef void (*org_freedesktop_DBus_name_has_owner_reply) (DBusGProxy *proxy, gboolean OUT_arg1, GError *error, gpointer userdata);

   220 

   221 static void

   222 org_freedesktop_DBus_name_has_owner_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   223 {

   224   DBusGAsyncData *data = user_data;

   225   GError *error = NULL;

   226   gboolean OUT_arg1;

   227   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_BOOLEAN, &OUT_arg1, G_TYPE_INVALID);

   228   (*(org_freedesktop_DBus_name_has_owner_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   229   return;

   230 }

   231 

   232 static

   233 #ifdef G_HAVE_INLINE

   234 inline

   235 #endif

   236 DBusGProxyCall*

   237 org_freedesktop_DBus_name_has_owner_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_name_has_owner_reply callback, gpointer userdata)

   238 

   239 {

   240   DBusGAsyncData *stuff;

   241   stuff = g_new (DBusGAsyncData, 1);

   242   stuff->cb = G_CALLBACK (callback);

   243   stuff->userdata = userdata;

   244   return dbus_g_proxy_begin_call (proxy, "NameHasOwner", org_freedesktop_DBus_name_has_owner_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   245 }

   246 static

   247 #ifdef G_HAVE_INLINE

   248 inline

   249 #endif

   250 gboolean

   251 org_freedesktop_DBus_list_names (DBusGProxy *proxy, char *** OUT_arg0, GError **error)

   252 

   253 {

   254   return dbus_g_proxy_call (proxy, "ListNames", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_arg0, G_TYPE_INVALID);

   255 }

   256 

   257 typedef void (*org_freedesktop_DBus_list_names_reply) (DBusGProxy *proxy, char * *OUT_arg0, GError *error, gpointer userdata);

   258 

   259 static void

   260 org_freedesktop_DBus_list_names_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   261 {

   262   DBusGAsyncData *data = user_data;

   263   GError *error = NULL;

   264   char ** OUT_arg0;

   265   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_arg0, G_TYPE_INVALID);

   266   (*(org_freedesktop_DBus_list_names_reply)data->cb) (proxy, OUT_arg0, error, data->userdata);

   267   return;

   268 }

   269 

   270 static

   271 #ifdef G_HAVE_INLINE

   272 inline

   273 #endif

   274 DBusGProxyCall*

   275 org_freedesktop_DBus_list_names_async (DBusGProxy *proxy, org_freedesktop_DBus_list_names_reply callback, gpointer userdata)

   276 

   277 {

   278   DBusGAsyncData *stuff;

   279   stuff = g_new (DBusGAsyncData, 1);

   280   stuff->cb = G_CALLBACK (callback);

   281   stuff->userdata = userdata;

   282   return dbus_g_proxy_begin_call (proxy, "ListNames", org_freedesktop_DBus_list_names_async_callback, stuff, g_free, G_TYPE_INVALID);

   283 }

   284 static

   285 #ifdef G_HAVE_INLINE

   286 inline

   287 #endif

   288 gboolean

   289 org_freedesktop_DBus_list_activatable_names (DBusGProxy *proxy, char *** OUT_arg0, GError **error)

   290 

   291 {

   292   return dbus_g_proxy_call (proxy, "ListActivatableNames", error, G_TYPE_INVALID, G_TYPE_STRV, OUT_arg0, G_TYPE_INVALID);

   293 }

   294 

   295 typedef void (*org_freedesktop_DBus_list_activatable_names_reply) (DBusGProxy *proxy, char * *OUT_arg0, GError *error, gpointer userdata);

   296 

   297 static void

   298 org_freedesktop_DBus_list_activatable_names_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   299 {

   300   DBusGAsyncData *data = user_data;

   301   GError *error = NULL;

   302   char ** OUT_arg0;

   303   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_arg0, G_TYPE_INVALID);

   304   (*(org_freedesktop_DBus_list_activatable_names_reply)data->cb) (proxy, OUT_arg0, error, data->userdata);

   305   return;

   306 }

   307 

   308 static

   309 #ifdef G_HAVE_INLINE

   310 inline

   311 #endif

   312 DBusGProxyCall*

   313 org_freedesktop_DBus_list_activatable_names_async (DBusGProxy *proxy, org_freedesktop_DBus_list_activatable_names_reply callback, gpointer userdata)

   314 

   315 {

   316   DBusGAsyncData *stuff;

   317   stuff = g_new (DBusGAsyncData, 1);

   318   stuff->cb = G_CALLBACK (callback);

   319   stuff->userdata = userdata;

   320   return dbus_g_proxy_begin_call (proxy, "ListActivatableNames", org_freedesktop_DBus_list_activatable_names_async_callback, stuff, g_free, G_TYPE_INVALID);

   321 }

   322 static

   323 #ifdef G_HAVE_INLINE

   324 inline

   325 #endif

   326 gboolean

   327 org_freedesktop_DBus_add_match (DBusGProxy *proxy, const char * IN_arg0, GError **error)

   328 

   329 {

   330   return dbus_g_proxy_call (proxy, "AddMatch", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_INVALID);

   331 }

   332 

   333 typedef void (*org_freedesktop_DBus_add_match_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

   334 

   335 static void

   336 org_freedesktop_DBus_add_match_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   337 {

   338   DBusGAsyncData *data = user_data;

   339   GError *error = NULL;

   340   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);

   341   (*(org_freedesktop_DBus_add_match_reply)data->cb) (proxy, error, data->userdata);

   342   return;

   343 }

   344 

   345 static

   346 #ifdef G_HAVE_INLINE

   347 inline

   348 #endif

   349 DBusGProxyCall*

   350 org_freedesktop_DBus_add_match_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_add_match_reply callback, gpointer userdata)

   351 

   352 {

   353   DBusGAsyncData *stuff;

   354   stuff = g_new (DBusGAsyncData, 1);

   355   stuff->cb = G_CALLBACK (callback);

   356   stuff->userdata = userdata;

   357   return dbus_g_proxy_begin_call (proxy, "AddMatch", org_freedesktop_DBus_add_match_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   358 }

   359 static

   360 #ifdef G_HAVE_INLINE

   361 inline

   362 #endif

   363 gboolean

   364 org_freedesktop_DBus_remove_match (DBusGProxy *proxy, const char * IN_arg0, GError **error)

   365 

   366 {

   367   return dbus_g_proxy_call (proxy, "RemoveMatch", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_INVALID);

   368 }

   369 

   370 typedef void (*org_freedesktop_DBus_remove_match_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

   371 

   372 static void

   373 org_freedesktop_DBus_remove_match_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   374 {

   375   DBusGAsyncData *data = user_data;

   376   GError *error = NULL;

   377   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);

   378   (*(org_freedesktop_DBus_remove_match_reply)data->cb) (proxy, error, data->userdata);

   379   return;

   380 }

   381 

   382 static

   383 #ifdef G_HAVE_INLINE

   384 inline

   385 #endif

   386 DBusGProxyCall*

   387 org_freedesktop_DBus_remove_match_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_remove_match_reply callback, gpointer userdata)

   388 

   389 {

   390   DBusGAsyncData *stuff;

   391   stuff = g_new (DBusGAsyncData, 1);

   392   stuff->cb = G_CALLBACK (callback);

   393   stuff->userdata = userdata;

   394   return dbus_g_proxy_begin_call (proxy, "RemoveMatch", org_freedesktop_DBus_remove_match_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   395 }

   396 static

   397 #ifdef G_HAVE_INLINE

   398 inline

   399 #endif

   400 gboolean

   401 org_freedesktop_DBus_get_name_owner (DBusGProxy *proxy, const char * IN_arg0, char ** OUT_arg1, GError **error)

   402 

   403 {

   404   return dbus_g_proxy_call (proxy, "GetNameOwner", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_STRING, OUT_arg1, G_TYPE_INVALID);

   405 }

   406 

   407 typedef void (*org_freedesktop_DBus_get_name_owner_reply) (DBusGProxy *proxy, char * OUT_arg1, GError *error, gpointer userdata);

   408 

   409 static void

   410 org_freedesktop_DBus_get_name_owner_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   411 {

   412   DBusGAsyncData *data = user_data;

   413   GError *error = NULL;

   414   char * OUT_arg1;

   415   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &OUT_arg1, G_TYPE_INVALID);

   416   (*(org_freedesktop_DBus_get_name_owner_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   417   return;

   418 }

   419 

   420 static

   421 #ifdef G_HAVE_INLINE

   422 inline

   423 #endif

   424 DBusGProxyCall*

   425 org_freedesktop_DBus_get_name_owner_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_get_name_owner_reply callback, gpointer userdata)

   426 

   427 {

   428   DBusGAsyncData *stuff;

   429   stuff = g_new (DBusGAsyncData, 1);

   430   stuff->cb = G_CALLBACK (callback);

   431   stuff->userdata = userdata;

   432   return dbus_g_proxy_begin_call (proxy, "GetNameOwner", org_freedesktop_DBus_get_name_owner_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   433 }

   434 static

   435 #ifdef G_HAVE_INLINE

   436 inline

   437 #endif

   438 gboolean

   439 org_freedesktop_DBus_list_queued_owners (DBusGProxy *proxy, const char * IN_arg0, char *** OUT_arg1, GError **error)

   440 

   441 {

   442   return dbus_g_proxy_call (proxy, "ListQueuedOwners", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_STRV, OUT_arg1, G_TYPE_INVALID);

   443 }

   444 

   445 typedef void (*org_freedesktop_DBus_list_queued_owners_reply) (DBusGProxy *proxy, char * *OUT_arg1, GError *error, gpointer userdata);

   446 

   447 static void

   448 org_freedesktop_DBus_list_queued_owners_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   449 {

   450   DBusGAsyncData *data = user_data;

   451   GError *error = NULL;

   452   char ** OUT_arg1;

   453   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRV, &OUT_arg1, G_TYPE_INVALID);

   454   (*(org_freedesktop_DBus_list_queued_owners_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   455   return;

   456 }

   457 

   458 static

   459 #ifdef G_HAVE_INLINE

   460 inline

   461 #endif

   462 DBusGProxyCall*

   463 org_freedesktop_DBus_list_queued_owners_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_list_queued_owners_reply callback, gpointer userdata)

   464 

   465 {

   466   DBusGAsyncData *stuff;

   467   stuff = g_new (DBusGAsyncData, 1);

   468   stuff->cb = G_CALLBACK (callback);

   469   stuff->userdata = userdata;

   470   return dbus_g_proxy_begin_call (proxy, "ListQueuedOwners", org_freedesktop_DBus_list_queued_owners_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   471 }

   472 static

   473 #ifdef G_HAVE_INLINE

   474 inline

   475 #endif

   476 gboolean

   477 org_freedesktop_DBus_get_connection_unix_user (DBusGProxy *proxy, const char * IN_arg0, guint* OUT_arg1, GError **error)

   478 

   479 {

   480   return dbus_g_proxy_call (proxy, "GetConnectionUnixUser", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_UINT, OUT_arg1, G_TYPE_INVALID);

   481 }

   482 

   483 typedef void (*org_freedesktop_DBus_get_connection_unix_user_reply) (DBusGProxy *proxy, guint OUT_arg1, GError *error, gpointer userdata);

   484 

   485 static void

   486 org_freedesktop_DBus_get_connection_unix_user_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   487 {

   488   DBusGAsyncData *data = user_data;

   489   GError *error = NULL;

   490   guint OUT_arg1;

   491   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_arg1, G_TYPE_INVALID);

   492   (*(org_freedesktop_DBus_get_connection_unix_user_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   493   return;

   494 }

   495 

   496 static

   497 #ifdef G_HAVE_INLINE

   498 inline

   499 #endif

   500 DBusGProxyCall*

   501 org_freedesktop_DBus_get_connection_unix_user_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_get_connection_unix_user_reply callback, gpointer userdata)

   502 

   503 {

   504   DBusGAsyncData *stuff;

   505   stuff = g_new (DBusGAsyncData, 1);

   506   stuff->cb = G_CALLBACK (callback);

   507   stuff->userdata = userdata;

   508   return dbus_g_proxy_begin_call (proxy, "GetConnectionUnixUser", org_freedesktop_DBus_get_connection_unix_user_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   509 }

   510 static

   511 #ifdef G_HAVE_INLINE

   512 inline

   513 #endif

   514 gboolean

   515 org_freedesktop_DBus_get_connection_unix_process_id (DBusGProxy *proxy, const char * IN_arg0, guint* OUT_arg1, GError **error)

   516 

   517 {

   518   return dbus_g_proxy_call (proxy, "GetConnectionUnixProcessID", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, G_TYPE_UINT, OUT_arg1, G_TYPE_INVALID);

   519 }

   520 

   521 typedef void (*org_freedesktop_DBus_get_connection_unix_process_id_reply) (DBusGProxy *proxy, guint OUT_arg1, GError *error, gpointer userdata);

   522 

   523 static void

   524 org_freedesktop_DBus_get_connection_unix_process_id_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   525 {

   526   DBusGAsyncData *data = user_data;

   527   GError *error = NULL;

   528   guint OUT_arg1;

   529   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &OUT_arg1, G_TYPE_INVALID);

   530   (*(org_freedesktop_DBus_get_connection_unix_process_id_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   531   return;

   532 }

   533 

   534 static

   535 #ifdef G_HAVE_INLINE

   536 inline

   537 #endif

   538 DBusGProxyCall*

   539 org_freedesktop_DBus_get_connection_unix_process_id_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_get_connection_unix_process_id_reply callback, gpointer userdata)

   540 

   541 {

   542   DBusGAsyncData *stuff;

   543   stuff = g_new (DBusGAsyncData, 1);

   544   stuff->cb = G_CALLBACK (callback);

   545   stuff->userdata = userdata;

   546   return dbus_g_proxy_begin_call (proxy, "GetConnectionUnixProcessID", org_freedesktop_DBus_get_connection_unix_process_id_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   547 }

   548 static

   549 #ifdef G_HAVE_INLINE

   550 inline

   551 #endif

   552 gboolean

   553 org_freedesktop_DBus_get_connection_se_linux_security_context (DBusGProxy *proxy, const char * IN_arg0, GArray** OUT_arg1, GError **error)

   554 

   555 {

   556   return dbus_g_proxy_call (proxy, "GetConnectionSELinuxSecurityContext", error, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID, dbus_g_type_get_collection ("GArray", G_TYPE_UCHAR), OUT_arg1, G_TYPE_INVALID);

   557 }

   558 

   559 typedef void (*org_freedesktop_DBus_get_connection_se_linux_security_context_reply) (DBusGProxy *proxy, GArray *OUT_arg1, GError *error, gpointer userdata);

   560 

   561 static void

   562 org_freedesktop_DBus_get_connection_se_linux_security_context_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   563 {

   564   DBusGAsyncData *data = user_data;

   565   GError *error = NULL;

   566   GArray* OUT_arg1;

   567   dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GArray", G_TYPE_UCHAR), &OUT_arg1, G_TYPE_INVALID);

   568   (*(org_freedesktop_DBus_get_connection_se_linux_security_context_reply)data->cb) (proxy, OUT_arg1, error, data->userdata);

   569   return;

   570 }

   571 

   572 static

   573 #ifdef G_HAVE_INLINE

   574 inline

   575 #endif

   576 DBusGProxyCall*

   577 org_freedesktop_DBus_get_connection_se_linux_security_context_async (DBusGProxy *proxy, const char * IN_arg0, org_freedesktop_DBus_get_connection_se_linux_security_context_reply callback, gpointer userdata)

   578 

   579 {

   580   DBusGAsyncData *stuff;

   581   stuff = g_new (DBusGAsyncData, 1);

   582   stuff->cb = G_CALLBACK (callback);

   583   stuff->userdata = userdata;

   584   return dbus_g_proxy_begin_call (proxy, "GetConnectionSELinuxSecurityContext", org_freedesktop_DBus_get_connection_se_linux_security_context_async_callback, stuff, g_free, G_TYPE_STRING, IN_arg0, G_TYPE_INVALID);

   585 }

   586 static

   587 #ifdef G_HAVE_INLINE

   588 inline

   589 #endif

   590 gboolean

   591 org_freedesktop_DBus_reload_config (DBusGProxy *proxy, GError **error)

   592 

   593 {

   594   return dbus_g_proxy_call (proxy, "ReloadConfig", error, G_TYPE_INVALID, G_TYPE_INVALID);

   595 }

   596 

   597 typedef void (*org_freedesktop_DBus_reload_config_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);

   598 

   599 static void

   600 org_freedesktop_DBus_reload_config_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)

   601 {

   602   DBusGAsyncData *data = user_data;

   603   GError *error = NULL;

   604   dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);

   605   (*(org_freedesktop_DBus_reload_config_reply)data->cb) (proxy, error, data->userdata);

   606   return;

   607 }

   608 

   609 static

   610 #ifdef G_HAVE_INLINE

   611 inline

   612 #endif

   613 DBusGProxyCall*

   614 org_freedesktop_DBus_reload_config_async (DBusGProxy *proxy, org_freedesktop_DBus_reload_config_reply callback, gpointer userdata)

   615 

   616 {

   617   DBusGAsyncData *stuff;

   618   stuff = g_new (DBusGAsyncData, 1);

   619   stuff->cb = G_CALLBACK (callback);

   620   stuff->userdata = userdata;

   621   return dbus_g_proxy_begin_call (proxy, "ReloadConfig", org_freedesktop_DBus_reload_config_async_callback, stuff, g_free, G_TYPE_INVALID);

   622 }

   623 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus */

   624 

   625 G_END_DECLS