1 /*

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

     3 

     4 * Redistribution and use in source and binary forms, with or without 

     5 * modification, are permitted provided that the following conditions are met:

     6 

     7 * Redistributions of source code must retain the above copyright notice, this 

     8 * list of conditions and the following disclaimer.

     9 * Redistributions in binary form must reproduce the above copyright notice, 

    10 * this list of conditions and the following disclaimer in the documentation 

    11 * and/or other materials provided with the distribution.

    12 * Neither the name of Nokia Corporation nor the names of its contributors 

    13 * may be used to endorse or promote products derived from this software 

    14 * without specific prior written permission.

    15 

    16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

    17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 

    18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 

    19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 

    20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 

    21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 

    22 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 

    23 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 

    24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

    25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    26 *

    27 * Description:

    28 *

    29 */

    30 

    31 

    32 

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

    34 

    35 #include <glib/gtypes.h>

    36 #include <glib/gerror.h>

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

    38 

    39 G_BEGIN_DECLS

    40 

    41 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    42 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable

    43 

    44 static

    45 #ifdef G_HAVE_INLINE

    46 inline

    47 #endif

    48 gboolean

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

    50 

    51 {

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

    53 }

    54 

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

    56 

    57 static void

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

    59 {

    60   DBusGAsyncData *data = user_data;

    61   GError *error = NULL;

    62   char * OUT_data;

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

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

    65   return;

    66 }

    67 

    68 static

    69 #ifdef G_HAVE_INLINE

    70 inline

    71 #endif

    72 DBusGProxyCall*

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

    74 

    75 {

    76   DBusGAsyncData *stuff;

    77   stuff = g_new (DBusGAsyncData, 1);

    78   stuff->cb = G_CALLBACK (callback);

    79   stuff->userdata = userdata;

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

    81 }

    82 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus_Introspectable */

    83 

    84 #ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    85 #define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus

    86 

    87 static

    88 #ifdef G_HAVE_INLINE

    89 inline

    90 #endif

    91 gboolean

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

    93 

    94 {

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

    96 }

    97 

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

    99 

   100 static void

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

   102 {

   103   DBusGAsyncData *data = user_data;

   104   GError *error = NULL;

   105   guint OUT_arg2;

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

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

   108   return;

   109 }

   110 

   111 static

   112 #ifdef G_HAVE_INLINE

   113 inline

   114 #endif

   115 DBusGProxyCall*

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

   117 

   118 {

   119   DBusGAsyncData *stuff;

   120   stuff = g_new (DBusGAsyncData, 1);

   121   stuff->cb = G_CALLBACK (callback);

   122   stuff->userdata = userdata;

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

   124 }

   125 static

   126 #ifdef G_HAVE_INLINE

   127 inline

   128 #endif

   129 gboolean

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

   131 

   132 {

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

   134 }

   135 

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

   137 

   138 static void

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

   140 {

   141   DBusGAsyncData *data = user_data;

   142   GError *error = NULL;

   143   guint OUT_arg1;

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

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

   146   return;

   147 }

   148 

   149 static

   150 #ifdef G_HAVE_INLINE

   151 inline

   152 #endif

   153 DBusGProxyCall*

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

   155 

   156 {

   157   DBusGAsyncData *stuff;

   158   stuff = g_new (DBusGAsyncData, 1);

   159   stuff->cb = G_CALLBACK (callback);

   160   stuff->userdata = userdata;

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

   162 }

   163 static

   164 #ifdef G_HAVE_INLINE

   165 inline

   166 #endif

   167 gboolean

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

   169 

   170 {

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

   172 }

   173 

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

   175 

   176 static void

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

   178 {

   179   DBusGAsyncData *data = user_data;

   180   GError *error = NULL;

   181   guint OUT_arg2;

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

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

   184   return;

   185 }

   186 

   187 static

   188 #ifdef G_HAVE_INLINE

   189 inline

   190 #endif

   191 DBusGProxyCall*

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

   193 

   194 {

   195   DBusGAsyncData *stuff;

   196   stuff = g_new (DBusGAsyncData, 1);

   197   stuff->cb = G_CALLBACK (callback);

   198   stuff->userdata = userdata;

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

   200 }

   201 static

   202 #ifdef G_HAVE_INLINE

   203 inline

   204 #endif

   205 gboolean

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

   207 

   208 {

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

   210 }

   211 

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

   213 

   214 static void

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

   216 {

   217   DBusGAsyncData *data = user_data;

   218   GError *error = NULL;

   219   char * OUT_arg0;

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

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

   222   return;

   223 }

   224 

   225 static

   226 #ifdef G_HAVE_INLINE

   227 inline

   228 #endif

   229 DBusGProxyCall*

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

   231 

   232 {

   233   DBusGAsyncData *stuff;

   234   stuff = g_new (DBusGAsyncData, 1);

   235   stuff->cb = G_CALLBACK (callback);

   236   stuff->userdata = userdata;

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

   238 }

   239 static

   240 #ifdef G_HAVE_INLINE

   241 inline

   242 #endif

   243 gboolean

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

   245 

   246 {

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

   248 }

   249 

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

   251 

   252 static void

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

   254 {

   255   DBusGAsyncData *data = user_data;

   256   GError *error = NULL;

   257   gboolean OUT_arg1;

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

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

   260   return;

   261 }

   262 

   263 static

   264 #ifdef G_HAVE_INLINE

   265 inline

   266 #endif

   267 DBusGProxyCall*

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

   269 

   270 {

   271   DBusGAsyncData *stuff;

   272   stuff = g_new (DBusGAsyncData, 1);

   273   stuff->cb = G_CALLBACK (callback);

   274   stuff->userdata = userdata;

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

   276 }

   277 static

   278 #ifdef G_HAVE_INLINE

   279 inline

   280 #endif

   281 gboolean

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

   283 

   284 {

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

   286 }

   287 

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

   289 

   290 static void

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

   292 {

   293   DBusGAsyncData *data = user_data;

   294   GError *error = NULL;

   295   char ** OUT_arg0;

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

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

   298   return;

   299 }

   300 

   301 static

   302 #ifdef G_HAVE_INLINE

   303 inline

   304 #endif

   305 DBusGProxyCall*

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

   307 

   308 {

   309   DBusGAsyncData *stuff;

   310   stuff = g_new (DBusGAsyncData, 1);

   311   stuff->cb = G_CALLBACK (callback);

   312   stuff->userdata = userdata;

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

   314 }

   315 static

   316 #ifdef G_HAVE_INLINE

   317 inline

   318 #endif

   319 gboolean

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

   321 

   322 {

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

   324 }

   325 

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

   327 

   328 static void

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

   330 {

   331   DBusGAsyncData *data = user_data;

   332   GError *error = NULL;

   333   char ** OUT_arg0;

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

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

   336   return;

   337 }

   338 

   339 static

   340 #ifdef G_HAVE_INLINE

   341 inline

   342 #endif

   343 DBusGProxyCall*

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

   345 

   346 {

   347   DBusGAsyncData *stuff;

   348   stuff = g_new (DBusGAsyncData, 1);

   349   stuff->cb = G_CALLBACK (callback);

   350   stuff->userdata = userdata;

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

   352 }

   353 static

   354 #ifdef G_HAVE_INLINE

   355 inline

   356 #endif

   357 gboolean

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

   359 

   360 {

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

   362 }

   363 

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

   365 

   366 static void

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

   368 {

   369   DBusGAsyncData *data = user_data;

   370   GError *error = NULL;

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

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

   373   return;

   374 }

   375 

   376 static

   377 #ifdef G_HAVE_INLINE

   378 inline

   379 #endif

   380 DBusGProxyCall*

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

   382 

   383 {

   384   DBusGAsyncData *stuff;

   385   stuff = g_new (DBusGAsyncData, 1);

   386   stuff->cb = G_CALLBACK (callback);

   387   stuff->userdata = userdata;

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

   389 }

   390 static

   391 #ifdef G_HAVE_INLINE

   392 inline

   393 #endif

   394 gboolean

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

   396 

   397 {

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

   399 }

   400 

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

   402 

   403 static void

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

   405 {

   406   DBusGAsyncData *data = user_data;

   407   GError *error = NULL;

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

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

   410   return;

   411 }

   412 

   413 static

   414 #ifdef G_HAVE_INLINE

   415 inline

   416 #endif

   417 DBusGProxyCall*

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

   419 

   420 {

   421   DBusGAsyncData *stuff;

   422   stuff = g_new (DBusGAsyncData, 1);

   423   stuff->cb = G_CALLBACK (callback);

   424   stuff->userdata = userdata;

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

   426 }

   427 static

   428 #ifdef G_HAVE_INLINE

   429 inline

   430 #endif

   431 gboolean

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

   433 

   434 {

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

   436 }

   437 

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

   439 

   440 static void

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

   442 {

   443   DBusGAsyncData *data = user_data;

   444   GError *error = NULL;

   445   char * OUT_arg1;

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

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

   448   return;

   449 }

   450 

   451 static

   452 #ifdef G_HAVE_INLINE

   453 inline

   454 #endif

   455 DBusGProxyCall*

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

   457 

   458 {

   459   DBusGAsyncData *stuff;

   460   stuff = g_new (DBusGAsyncData, 1);

   461   stuff->cb = G_CALLBACK (callback);

   462   stuff->userdata = userdata;

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

   464 }

   465 static

   466 #ifdef G_HAVE_INLINE

   467 inline

   468 #endif

   469 gboolean

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

   471 

   472 {

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

   474 }

   475 

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

   477 

   478 static void

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

   480 {

   481   DBusGAsyncData *data = user_data;

   482   GError *error = NULL;

   483   char ** OUT_arg1;

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

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

   486   return;

   487 }

   488 

   489 static

   490 #ifdef G_HAVE_INLINE

   491 inline

   492 #endif

   493 DBusGProxyCall*

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

   495 

   496 {

   497   DBusGAsyncData *stuff;

   498   stuff = g_new (DBusGAsyncData, 1);

   499   stuff->cb = G_CALLBACK (callback);

   500   stuff->userdata = userdata;

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

   502 }

   503 static

   504 #ifdef G_HAVE_INLINE

   505 inline

   506 #endif

   507 gboolean

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

   509 

   510 {

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

   512 }

   513 

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

   515 

   516 static void

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

   518 {

   519   DBusGAsyncData *data = user_data;

   520   GError *error = NULL;

   521   guint OUT_arg1;

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

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

   524   return;

   525 }

   526 

   527 static

   528 #ifdef G_HAVE_INLINE

   529 inline

   530 #endif

   531 DBusGProxyCall*

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

   533 

   534 {

   535   DBusGAsyncData *stuff;

   536   stuff = g_new (DBusGAsyncData, 1);

   537   stuff->cb = G_CALLBACK (callback);

   538   stuff->userdata = userdata;

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

   540 }

   541 static

   542 #ifdef G_HAVE_INLINE

   543 inline

   544 #endif

   545 gboolean

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

   547 

   548 {

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

   550 }

   551 

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

   553 

   554 static void

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

   556 {

   557   DBusGAsyncData *data = user_data;

   558   GError *error = NULL;

   559   guint OUT_arg1;

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

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

   562   return;

   563 }

   564 

   565 static

   566 #ifdef G_HAVE_INLINE

   567 inline

   568 #endif

   569 DBusGProxyCall*

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

   571 

   572 {

   573   DBusGAsyncData *stuff;

   574   stuff = g_new (DBusGAsyncData, 1);

   575   stuff->cb = G_CALLBACK (callback);

   576   stuff->userdata = userdata;

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

   578 }

   579 static

   580 #ifdef G_HAVE_INLINE

   581 inline

   582 #endif

   583 gboolean

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

   585 

   586 {

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

   588 }

   589 

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

   591 

   592 static void

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

   594 {

   595   DBusGAsyncData *data = user_data;

   596   GError *error = NULL;

   597   GArray* OUT_arg1;

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

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

   600   return;

   601 }

   602 

   603 static

   604 #ifdef G_HAVE_INLINE

   605 inline

   606 #endif

   607 DBusGProxyCall*

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

   609 

   610 {

   611   DBusGAsyncData *stuff;

   612   stuff = g_new (DBusGAsyncData, 1);

   613   stuff->cb = G_CALLBACK (callback);

   614   stuff->userdata = userdata;

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

   616 }

   617 static

   618 #ifdef G_HAVE_INLINE

   619 inline

   620 #endif

   621 gboolean

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

   623 

   624 {

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

   626 }

   627 

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

   629 

   630 static void

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

   632 {

   633   DBusGAsyncData *data = user_data;

   634   GError *error = NULL;

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

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

   637   return;

   638 }

   639 

   640 static

   641 #ifdef G_HAVE_INLINE

   642 inline

   643 #endif

   644 DBusGProxyCall*

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

   646 

   647 {

   648   DBusGAsyncData *stuff;

   649   stuff = g_new (DBusGAsyncData, 1);

   650   stuff->cb = G_CALLBACK (callback);

   651   stuff->userdata = userdata;

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

   653 }

   654 #endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_DBus */

   655 

   656 G_END_DECLS