MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/ofdbus/dbus-glib/dbus/dbus-glib-bindings.h
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 

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

    22 

    23 #include <glib/gtypes.h>

    24 #include <glib/gerror.h>

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

    26 

    27 G_BEGIN_DECLS

    28 

    29 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    30 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    31 

    32 static

    33 #ifdef G_HAVE_INLINE

    34 inline

    35 #endif

    36 gboolean

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

    38 

    39 {

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

    41 }

    42 

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

    44 

    45 static void

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

    47 {

    48   DBusGAsyncData *data = user_data;

    49   GError *error = NULL;

    50   char * OUT_data;

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

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

    53   return;

    54 }

    55 

    56 static

    57 #ifdef G_HAVE_INLINE

    58 inline

    59 #endif

    60 DBusGProxyCall*

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

    62 

    63 {

    64   DBusGAsyncData *stuff;

    65   stuff = g_new (DBusGAsyncData, 1);

    66   stuff->cb = G_CALLBACK (callback);

    67   stuff->userdata = userdata;

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

    69 }

    70 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable */

    71 

    72 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    73 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    74 

    75 static

    76 #ifdef G_HAVE_INLINE

    77 inline

    78 #endif

    79 gboolean

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

    81 

    82 {

    83   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);

    84 }

    85 

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

    87 

    88 static void

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

    90 {

    91   DBusGAsyncData *data = user_data;

    92   GError *error = NULL;

    93   guint OUT_arg2;

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

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

    96   return;

    97 }

    98 

    99 static

   100 #ifdef G_HAVE_INLINE

   101 inline

   102 #endif

   103 DBusGProxyCall*

   104 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)

   105 

   106 {

   107   DBusGAsyncData *stuff;

   108   stuff = g_new (DBusGAsyncData, 1);

   109   stuff->cb = G_CALLBACK (callback);

   110   stuff->userdata = userdata;

   111   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);

   112 }

   113 static

   114 #ifdef G_HAVE_INLINE

   115 inline

   116 #endif

   117 gboolean

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

   119 

   120 {

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

   122 }

   123 

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

   125 

   126 static void

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

   128 {

   129   DBusGAsyncData *data = user_data;

   130   GError *error = NULL;

   131   guint OUT_arg1;

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

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

   134   return;

   135 }

   136 

   137 static

   138 #ifdef G_HAVE_INLINE

   139 inline

   140 #endif

   141 DBusGProxyCall*

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

   143 

   144 {

   145   DBusGAsyncData *stuff;

   146   stuff = g_new (DBusGAsyncData, 1);

   147   stuff->cb = G_CALLBACK (callback);

   148   stuff->userdata = userdata;

   149   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);

   150 }

   151 static

   152 #ifdef G_HAVE_INLINE

   153 inline

   154 #endif

   155 gboolean

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

   157 

   158 {

   159   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);

   160 }

   161 

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

   163 

   164 static void

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

   166 {

   167   DBusGAsyncData *data = user_data;

   168   GError *error = NULL;

   169   guint OUT_arg2;

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

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

   172   return;

   173 }

   174 

   175 static

   176 #ifdef G_HAVE_INLINE

   177 inline

   178 #endif

   179 DBusGProxyCall*

   180 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)

   181 

   182 {

   183   DBusGAsyncData *stuff;

   184   stuff = g_new (DBusGAsyncData, 1);

   185   stuff->cb = G_CALLBACK (callback);

   186   stuff->userdata = userdata;

   187   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);

   188 }

   189 static

   190 #ifdef G_HAVE_INLINE

   191 inline

   192 #endif

   193 gboolean

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

   195 

   196 {

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

   198 }

   199 

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

   201 

   202 static void

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

   204 {

   205   DBusGAsyncData *data = user_data;

   206   GError *error = NULL;

   207   char * OUT_arg0;

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

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

   210   return;

   211 }

   212 

   213 static

   214 #ifdef G_HAVE_INLINE

   215 inline

   216 #endif

   217 DBusGProxyCall*

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

   219 

   220 {

   221   DBusGAsyncData *stuff;

   222   stuff = g_new (DBusGAsyncData, 1);

   223   stuff->cb = G_CALLBACK (callback);

   224   stuff->userdata = userdata;

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

   226 }

   227 static

   228 #ifdef G_HAVE_INLINE

   229 inline

   230 #endif

   231 gboolean

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

   233 

   234 {

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

   236 }

   237 

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

   239 

   240 static void

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

   242 {

   243   DBusGAsyncData *data = user_data;

   244   GError *error = NULL;

   245   gboolean OUT_arg1;

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

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

   248   return;

   249 }

   250 

   251 static

   252 #ifdef G_HAVE_INLINE

   253 inline

   254 #endif

   255 DBusGProxyCall*

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

   257 

   258 {

   259   DBusGAsyncData *stuff;

   260   stuff = g_new (DBusGAsyncData, 1);

   261   stuff->cb = G_CALLBACK (callback);

   262   stuff->userdata = userdata;

   263   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);

   264 }

   265 static

   266 #ifdef G_HAVE_INLINE

   267 inline

   268 #endif

   269 gboolean

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

   271 

   272 {

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

   274 }

   275 

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

   277 

   278 static void

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

   280 {

   281   DBusGAsyncData *data = user_data;

   282   GError *error = NULL;

   283   char ** OUT_arg0;

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

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

   286   return;

   287 }

   288 

   289 static

   290 #ifdef G_HAVE_INLINE

   291 inline

   292 #endif

   293 DBusGProxyCall*

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

   295 

   296 {

   297   DBusGAsyncData *stuff;

   298   stuff = g_new (DBusGAsyncData, 1);

   299   stuff->cb = G_CALLBACK (callback);

   300   stuff->userdata = userdata;

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

   302 }

   303 static

   304 #ifdef G_HAVE_INLINE

   305 inline

   306 #endif

   307 gboolean

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

   309 

   310 {

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

   312 }

   313 

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

   315 

   316 static void

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

   318 {

   319   DBusGAsyncData *data = user_data;

   320   GError *error = NULL;

   321   char ** OUT_arg0;

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

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

   324   return;

   325 }

   326 

   327 static

   328 #ifdef G_HAVE_INLINE

   329 inline

   330 #endif

   331 DBusGProxyCall*

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

   333 

   334 {

   335   DBusGAsyncData *stuff;

   336   stuff = g_new (DBusGAsyncData, 1);

   337   stuff->cb = G_CALLBACK (callback);

   338   stuff->userdata = userdata;

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

   340 }

   341 static

   342 #ifdef G_HAVE_INLINE

   343 inline

   344 #endif

   345 gboolean

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

   347 

   348 {

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

   350 }

   351 

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

   353 

   354 static void

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

   356 {

   357   DBusGAsyncData *data = user_data;

   358   GError *error = NULL;

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

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

   361   return;

   362 }

   363 

   364 static

   365 #ifdef G_HAVE_INLINE

   366 inline

   367 #endif

   368 DBusGProxyCall*

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

   370 

   371 {

   372   DBusGAsyncData *stuff;

   373   stuff = g_new (DBusGAsyncData, 1);

   374   stuff->cb = G_CALLBACK (callback);

   375   stuff->userdata = userdata;

   376   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);

   377 }

   378 static

   379 #ifdef G_HAVE_INLINE

   380 inline

   381 #endif

   382 gboolean

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

   384 

   385 {

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

   387 }

   388 

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

   390 

   391 static void

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

   393 {

   394   DBusGAsyncData *data = user_data;

   395   GError *error = NULL;

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

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

   398   return;

   399 }

   400 

   401 static

   402 #ifdef G_HAVE_INLINE

   403 inline

   404 #endif

   405 DBusGProxyCall*

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

   407 

   408 {

   409   DBusGAsyncData *stuff;

   410   stuff = g_new (DBusGAsyncData, 1);

   411   stuff->cb = G_CALLBACK (callback);

   412   stuff->userdata = userdata;

   413   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);

   414 }

   415 static

   416 #ifdef G_HAVE_INLINE

   417 inline

   418 #endif

   419 gboolean

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

   421 

   422 {

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

   424 }

   425 

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

   427 

   428 static void

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

   430 {

   431   DBusGAsyncData *data = user_data;

   432   GError *error = NULL;

   433   char * OUT_arg1;

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

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

   436   return;

   437 }

   438 

   439 static

   440 #ifdef G_HAVE_INLINE

   441 inline

   442 #endif

   443 DBusGProxyCall*

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

   445 

   446 {

   447   DBusGAsyncData *stuff;

   448   stuff = g_new (DBusGAsyncData, 1);

   449   stuff->cb = G_CALLBACK (callback);

   450   stuff->userdata = userdata;

   451   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);

   452 }

   453 static

   454 #ifdef G_HAVE_INLINE

   455 inline

   456 #endif

   457 gboolean

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

   459 

   460 {

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

   462 }

   463 

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

   465 

   466 static void

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

   468 {

   469   DBusGAsyncData *data = user_data;

   470   GError *error = NULL;

   471   char ** OUT_arg1;

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

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

   474   return;

   475 }

   476 

   477 static

   478 #ifdef G_HAVE_INLINE

   479 inline

   480 #endif

   481 DBusGProxyCall*

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

   483 

   484 {

   485   DBusGAsyncData *stuff;

   486   stuff = g_new (DBusGAsyncData, 1);

   487   stuff->cb = G_CALLBACK (callback);

   488   stuff->userdata = userdata;

   489   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);

   490 }

   491 static

   492 #ifdef G_HAVE_INLINE

   493 inline

   494 #endif

   495 gboolean

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

   497 

   498 {

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

   500 }

   501 

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

   503 

   504 static void

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

   506 {

   507   DBusGAsyncData *data = user_data;

   508   GError *error = NULL;

   509   guint OUT_arg1;

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

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

   512   return;

   513 }

   514 

   515 static

   516 #ifdef G_HAVE_INLINE

   517 inline

   518 #endif

   519 DBusGProxyCall*

   520 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)

   521 

   522 {

   523   DBusGAsyncData *stuff;

   524   stuff = g_new (DBusGAsyncData, 1);

   525   stuff->cb = G_CALLBACK (callback);

   526   stuff->userdata = userdata;

   527   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);

   528 }

   529 static

   530 #ifdef G_HAVE_INLINE

   531 inline

   532 #endif

   533 gboolean

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

   535 

   536 {

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

   538 }

   539 

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

   541 

   542 static void

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

   544 {

   545   DBusGAsyncData *data = user_data;

   546   GError *error = NULL;

   547   guint OUT_arg1;

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

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

   550   return;

   551 }

   552 

   553 static

   554 #ifdef G_HAVE_INLINE

   555 inline

   556 #endif

   557 DBusGProxyCall*

   558 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)

   559 

   560 {

   561   DBusGAsyncData *stuff;

   562   stuff = g_new (DBusGAsyncData, 1);

   563   stuff->cb = G_CALLBACK (callback);

   564   stuff->userdata = userdata;

   565   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);

   566 }

   567 static

   568 #ifdef G_HAVE_INLINE

   569 inline

   570 #endif

   571 gboolean

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

   573 

   574 {

   575   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);

   576 }

   577 

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

   579 

   580 static void

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

   582 {

   583   DBusGAsyncData *data = user_data;

   584   GError *error = NULL;

   585   GArray* OUT_arg1;

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

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

   588   return;

   589 }

   590 

   591 static

   592 #ifdef G_HAVE_INLINE

   593 inline

   594 #endif

   595 DBusGProxyCall*

   596 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)

   597 

   598 {

   599   DBusGAsyncData *stuff;

   600   stuff = g_new (DBusGAsyncData, 1);

   601   stuff->cb = G_CALLBACK (callback);

   602   stuff->userdata = userdata;

   603   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);

   604 }

   605 static

   606 #ifdef G_HAVE_INLINE

   607 inline

   608 #endif

   609 gboolean

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

   611 

   612 {

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

   614 }

   615 

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

   617 

   618 static void

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

   620 {

   621   DBusGAsyncData *data = user_data;

   622   GError *error = NULL;

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

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

   625   return;

   626 }

   627 

   628 static

   629 #ifdef G_HAVE_INLINE

   630 inline

   631 #endif

   632 DBusGProxyCall*

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

   634 

   635 {

   636   DBusGAsyncData *stuff;

   637   stuff = g_new (DBusGAsyncData, 1);

   638   stuff->cb = G_CALLBACK (callback);

   639   stuff->userdata = userdata;

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

   641 }

   642 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus */

   643 

   644 G_END_DECLS
Symaptic