~skypce/indicator-session/indicator-session

« back to all changes in this revision

Viewing changes to src/accounts-service-user-client.h

  • Committer: Cesar R. Cid Mendez
  • Date: 2014-12-21 19:32:13 UTC
  • mfrom: (1.1.52)
  • Revision ID: skypce@gmail.com-20141221193213-mtxf2rkk4d0ud6pp
Added power-commands directly to source code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* Generated by dbus-binding-tool; do not edit! */
2
 
 
3
 
#include <glib.h>
4
 
#include <dbus/dbus-glib.h>
5
 
 
6
 
G_BEGIN_DECLS
7
 
 
8
 
#ifndef _DBUS_GLIB_ASYNC_DATA_FREE
9
 
#define _DBUS_GLIB_ASYNC_DATA_FREE
10
 
static
11
 
#ifdef G_HAVE_INLINE
12
 
inline
13
 
#endif
14
 
void
15
 
_dbus_glib_async_data_free (gpointer stuff)
16
 
{
17
 
        g_slice_free (DBusGAsyncData, stuff);
18
 
}
19
 
#endif
20
 
 
21
 
#ifndef DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_Accounts_User
22
 
#define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_Accounts_User
23
 
 
24
 
static
25
 
#ifdef G_HAVE_INLINE
26
 
inline
27
 
#endif
28
 
gboolean
29
 
org_freedesktop_Accounts_User_set_user_name (DBusGProxy *proxy, const char * IN_name, GError **error)
30
 
 
31
 
{
32
 
  return dbus_g_proxy_call (proxy, "SetUserName", error, G_TYPE_STRING, IN_name, G_TYPE_INVALID, G_TYPE_INVALID);
33
 
}
34
 
 
35
 
typedef void (*org_freedesktop_Accounts_User_set_user_name_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
36
 
 
37
 
static void
38
 
org_freedesktop_Accounts_User_set_user_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
39
 
{
40
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
41
 
  GError *error = NULL;
42
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
43
 
  (*(org_freedesktop_Accounts_User_set_user_name_reply)data->cb) (proxy, error, data->userdata);
44
 
  return;
45
 
}
46
 
 
47
 
static
48
 
#ifdef G_HAVE_INLINE
49
 
inline
50
 
#endif
51
 
DBusGProxyCall*
52
 
org_freedesktop_Accounts_User_set_user_name_async (DBusGProxy *proxy, const char * IN_name, org_freedesktop_Accounts_User_set_user_name_reply callback, gpointer userdata)
53
 
 
54
 
{
55
 
  DBusGAsyncData *stuff;
56
 
  stuff = g_slice_new (DBusGAsyncData);
57
 
  stuff->cb = G_CALLBACK (callback);
58
 
  stuff->userdata = userdata;
59
 
  return dbus_g_proxy_begin_call (proxy, "SetUserName", org_freedesktop_Accounts_User_set_user_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_name, G_TYPE_INVALID);
60
 
}
61
 
static
62
 
#ifdef G_HAVE_INLINE
63
 
inline
64
 
#endif
65
 
gboolean
66
 
org_freedesktop_Accounts_User_set_real_name (DBusGProxy *proxy, const char * IN_name, GError **error)
67
 
 
68
 
{
69
 
  return dbus_g_proxy_call (proxy, "SetRealName", error, G_TYPE_STRING, IN_name, G_TYPE_INVALID, G_TYPE_INVALID);
70
 
}
71
 
 
72
 
typedef void (*org_freedesktop_Accounts_User_set_real_name_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
73
 
 
74
 
static void
75
 
org_freedesktop_Accounts_User_set_real_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
76
 
{
77
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
78
 
  GError *error = NULL;
79
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
80
 
  (*(org_freedesktop_Accounts_User_set_real_name_reply)data->cb) (proxy, error, data->userdata);
81
 
  return;
82
 
}
83
 
 
84
 
static
85
 
#ifdef G_HAVE_INLINE
86
 
inline
87
 
#endif
88
 
DBusGProxyCall*
89
 
org_freedesktop_Accounts_User_set_real_name_async (DBusGProxy *proxy, const char * IN_name, org_freedesktop_Accounts_User_set_real_name_reply callback, gpointer userdata)
90
 
 
91
 
{
92
 
  DBusGAsyncData *stuff;
93
 
  stuff = g_slice_new (DBusGAsyncData);
94
 
  stuff->cb = G_CALLBACK (callback);
95
 
  stuff->userdata = userdata;
96
 
  return dbus_g_proxy_begin_call (proxy, "SetRealName", org_freedesktop_Accounts_User_set_real_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_name, G_TYPE_INVALID);
97
 
}
98
 
static
99
 
#ifdef G_HAVE_INLINE
100
 
inline
101
 
#endif
102
 
gboolean
103
 
org_freedesktop_Accounts_User_set_email (DBusGProxy *proxy, const char * IN_email, GError **error)
104
 
 
105
 
{
106
 
  return dbus_g_proxy_call (proxy, "SetEmail", error, G_TYPE_STRING, IN_email, G_TYPE_INVALID, G_TYPE_INVALID);
107
 
}
108
 
 
109
 
typedef void (*org_freedesktop_Accounts_User_set_email_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
110
 
 
111
 
static void
112
 
org_freedesktop_Accounts_User_set_email_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
113
 
{
114
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
115
 
  GError *error = NULL;
116
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
117
 
  (*(org_freedesktop_Accounts_User_set_email_reply)data->cb) (proxy, error, data->userdata);
118
 
  return;
119
 
}
120
 
 
121
 
static
122
 
#ifdef G_HAVE_INLINE
123
 
inline
124
 
#endif
125
 
DBusGProxyCall*
126
 
org_freedesktop_Accounts_User_set_email_async (DBusGProxy *proxy, const char * IN_email, org_freedesktop_Accounts_User_set_email_reply callback, gpointer userdata)
127
 
 
128
 
{
129
 
  DBusGAsyncData *stuff;
130
 
  stuff = g_slice_new (DBusGAsyncData);
131
 
  stuff->cb = G_CALLBACK (callback);
132
 
  stuff->userdata = userdata;
133
 
  return dbus_g_proxy_begin_call (proxy, "SetEmail", org_freedesktop_Accounts_User_set_email_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_email, G_TYPE_INVALID);
134
 
}
135
 
static
136
 
#ifdef G_HAVE_INLINE
137
 
inline
138
 
#endif
139
 
gboolean
140
 
org_freedesktop_Accounts_User_set_language (DBusGProxy *proxy, const char * IN_language, GError **error)
141
 
 
142
 
{
143
 
  return dbus_g_proxy_call (proxy, "SetLanguage", error, G_TYPE_STRING, IN_language, G_TYPE_INVALID, G_TYPE_INVALID);
144
 
}
145
 
 
146
 
typedef void (*org_freedesktop_Accounts_User_set_language_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
147
 
 
148
 
static void
149
 
org_freedesktop_Accounts_User_set_language_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
150
 
{
151
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
152
 
  GError *error = NULL;
153
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
154
 
  (*(org_freedesktop_Accounts_User_set_language_reply)data->cb) (proxy, error, data->userdata);
155
 
  return;
156
 
}
157
 
 
158
 
static
159
 
#ifdef G_HAVE_INLINE
160
 
inline
161
 
#endif
162
 
DBusGProxyCall*
163
 
org_freedesktop_Accounts_User_set_language_async (DBusGProxy *proxy, const char * IN_language, org_freedesktop_Accounts_User_set_language_reply callback, gpointer userdata)
164
 
 
165
 
{
166
 
  DBusGAsyncData *stuff;
167
 
  stuff = g_slice_new (DBusGAsyncData);
168
 
  stuff->cb = G_CALLBACK (callback);
169
 
  stuff->userdata = userdata;
170
 
  return dbus_g_proxy_begin_call (proxy, "SetLanguage", org_freedesktop_Accounts_User_set_language_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_language, G_TYPE_INVALID);
171
 
}
172
 
static
173
 
#ifdef G_HAVE_INLINE
174
 
inline
175
 
#endif
176
 
gboolean
177
 
org_freedesktop_Accounts_User_set_location (DBusGProxy *proxy, const char * IN_location, GError **error)
178
 
 
179
 
{
180
 
  return dbus_g_proxy_call (proxy, "SetLocation", error, G_TYPE_STRING, IN_location, G_TYPE_INVALID, G_TYPE_INVALID);
181
 
}
182
 
 
183
 
typedef void (*org_freedesktop_Accounts_User_set_location_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
184
 
 
185
 
static void
186
 
org_freedesktop_Accounts_User_set_location_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
187
 
{
188
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
189
 
  GError *error = NULL;
190
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
191
 
  (*(org_freedesktop_Accounts_User_set_location_reply)data->cb) (proxy, error, data->userdata);
192
 
  return;
193
 
}
194
 
 
195
 
static
196
 
#ifdef G_HAVE_INLINE
197
 
inline
198
 
#endif
199
 
DBusGProxyCall*
200
 
org_freedesktop_Accounts_User_set_location_async (DBusGProxy *proxy, const char * IN_location, org_freedesktop_Accounts_User_set_location_reply callback, gpointer userdata)
201
 
 
202
 
{
203
 
  DBusGAsyncData *stuff;
204
 
  stuff = g_slice_new (DBusGAsyncData);
205
 
  stuff->cb = G_CALLBACK (callback);
206
 
  stuff->userdata = userdata;
207
 
  return dbus_g_proxy_begin_call (proxy, "SetLocation", org_freedesktop_Accounts_User_set_location_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_location, G_TYPE_INVALID);
208
 
}
209
 
static
210
 
#ifdef G_HAVE_INLINE
211
 
inline
212
 
#endif
213
 
gboolean
214
 
org_freedesktop_Accounts_User_set_home_directory (DBusGProxy *proxy, const char * IN_homedir, GError **error)
215
 
 
216
 
{
217
 
  return dbus_g_proxy_call (proxy, "SetHomeDirectory", error, G_TYPE_STRING, IN_homedir, G_TYPE_INVALID, G_TYPE_INVALID);
218
 
}
219
 
 
220
 
typedef void (*org_freedesktop_Accounts_User_set_home_directory_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
221
 
 
222
 
static void
223
 
org_freedesktop_Accounts_User_set_home_directory_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
224
 
{
225
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
226
 
  GError *error = NULL;
227
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
228
 
  (*(org_freedesktop_Accounts_User_set_home_directory_reply)data->cb) (proxy, error, data->userdata);
229
 
  return;
230
 
}
231
 
 
232
 
static
233
 
#ifdef G_HAVE_INLINE
234
 
inline
235
 
#endif
236
 
DBusGProxyCall*
237
 
org_freedesktop_Accounts_User_set_home_directory_async (DBusGProxy *proxy, const char * IN_homedir, org_freedesktop_Accounts_User_set_home_directory_reply callback, gpointer userdata)
238
 
 
239
 
{
240
 
  DBusGAsyncData *stuff;
241
 
  stuff = g_slice_new (DBusGAsyncData);
242
 
  stuff->cb = G_CALLBACK (callback);
243
 
  stuff->userdata = userdata;
244
 
  return dbus_g_proxy_begin_call (proxy, "SetHomeDirectory", org_freedesktop_Accounts_User_set_home_directory_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_homedir, G_TYPE_INVALID);
245
 
}
246
 
static
247
 
#ifdef G_HAVE_INLINE
248
 
inline
249
 
#endif
250
 
gboolean
251
 
org_freedesktop_Accounts_User_set_shell (DBusGProxy *proxy, const char * IN_shell, GError **error)
252
 
 
253
 
{
254
 
  return dbus_g_proxy_call (proxy, "SetShell", error, G_TYPE_STRING, IN_shell, G_TYPE_INVALID, G_TYPE_INVALID);
255
 
}
256
 
 
257
 
typedef void (*org_freedesktop_Accounts_User_set_shell_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
258
 
 
259
 
static void
260
 
org_freedesktop_Accounts_User_set_shell_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
261
 
{
262
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
263
 
  GError *error = NULL;
264
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
265
 
  (*(org_freedesktop_Accounts_User_set_shell_reply)data->cb) (proxy, error, data->userdata);
266
 
  return;
267
 
}
268
 
 
269
 
static
270
 
#ifdef G_HAVE_INLINE
271
 
inline
272
 
#endif
273
 
DBusGProxyCall*
274
 
org_freedesktop_Accounts_User_set_shell_async (DBusGProxy *proxy, const char * IN_shell, org_freedesktop_Accounts_User_set_shell_reply callback, gpointer userdata)
275
 
 
276
 
{
277
 
  DBusGAsyncData *stuff;
278
 
  stuff = g_slice_new (DBusGAsyncData);
279
 
  stuff->cb = G_CALLBACK (callback);
280
 
  stuff->userdata = userdata;
281
 
  return dbus_g_proxy_begin_call (proxy, "SetShell", org_freedesktop_Accounts_User_set_shell_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_shell, G_TYPE_INVALID);
282
 
}
283
 
static
284
 
#ifdef G_HAVE_INLINE
285
 
inline
286
 
#endif
287
 
gboolean
288
 
org_freedesktop_Accounts_User_set_icon_file (DBusGProxy *proxy, const char * IN_filename, GError **error)
289
 
 
290
 
{
291
 
  return dbus_g_proxy_call (proxy, "SetIconFile", error, G_TYPE_STRING, IN_filename, G_TYPE_INVALID, G_TYPE_INVALID);
292
 
}
293
 
 
294
 
typedef void (*org_freedesktop_Accounts_User_set_icon_file_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
295
 
 
296
 
static void
297
 
org_freedesktop_Accounts_User_set_icon_file_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
298
 
{
299
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
300
 
  GError *error = NULL;
301
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
302
 
  (*(org_freedesktop_Accounts_User_set_icon_file_reply)data->cb) (proxy, error, data->userdata);
303
 
  return;
304
 
}
305
 
 
306
 
static
307
 
#ifdef G_HAVE_INLINE
308
 
inline
309
 
#endif
310
 
DBusGProxyCall*
311
 
org_freedesktop_Accounts_User_set_icon_file_async (DBusGProxy *proxy, const char * IN_filename, org_freedesktop_Accounts_User_set_icon_file_reply callback, gpointer userdata)
312
 
 
313
 
{
314
 
  DBusGAsyncData *stuff;
315
 
  stuff = g_slice_new (DBusGAsyncData);
316
 
  stuff->cb = G_CALLBACK (callback);
317
 
  stuff->userdata = userdata;
318
 
  return dbus_g_proxy_begin_call (proxy, "SetIconFile", org_freedesktop_Accounts_User_set_icon_file_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_filename, G_TYPE_INVALID);
319
 
}
320
 
static
321
 
#ifdef G_HAVE_INLINE
322
 
inline
323
 
#endif
324
 
gboolean
325
 
org_freedesktop_Accounts_User_set_locked (DBusGProxy *proxy, const gboolean IN_locked, GError **error)
326
 
 
327
 
{
328
 
  return dbus_g_proxy_call (proxy, "SetLocked", error, G_TYPE_BOOLEAN, IN_locked, G_TYPE_INVALID, G_TYPE_INVALID);
329
 
}
330
 
 
331
 
typedef void (*org_freedesktop_Accounts_User_set_locked_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
332
 
 
333
 
static void
334
 
org_freedesktop_Accounts_User_set_locked_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
335
 
{
336
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
337
 
  GError *error = NULL;
338
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
339
 
  (*(org_freedesktop_Accounts_User_set_locked_reply)data->cb) (proxy, error, data->userdata);
340
 
  return;
341
 
}
342
 
 
343
 
static
344
 
#ifdef G_HAVE_INLINE
345
 
inline
346
 
#endif
347
 
DBusGProxyCall*
348
 
org_freedesktop_Accounts_User_set_locked_async (DBusGProxy *proxy, const gboolean IN_locked, org_freedesktop_Accounts_User_set_locked_reply callback, gpointer userdata)
349
 
 
350
 
{
351
 
  DBusGAsyncData *stuff;
352
 
  stuff = g_slice_new (DBusGAsyncData);
353
 
  stuff->cb = G_CALLBACK (callback);
354
 
  stuff->userdata = userdata;
355
 
  return dbus_g_proxy_begin_call (proxy, "SetLocked", org_freedesktop_Accounts_User_set_locked_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_locked, G_TYPE_INVALID);
356
 
}
357
 
static
358
 
#ifdef G_HAVE_INLINE
359
 
inline
360
 
#endif
361
 
gboolean
362
 
org_freedesktop_Accounts_User_set_account_type (DBusGProxy *proxy, const gint IN_accountType, GError **error)
363
 
 
364
 
{
365
 
  return dbus_g_proxy_call (proxy, "SetAccountType", error, G_TYPE_INT, IN_accountType, G_TYPE_INVALID, G_TYPE_INVALID);
366
 
}
367
 
 
368
 
typedef void (*org_freedesktop_Accounts_User_set_account_type_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
369
 
 
370
 
static void
371
 
org_freedesktop_Accounts_User_set_account_type_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
372
 
{
373
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
374
 
  GError *error = NULL;
375
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
376
 
  (*(org_freedesktop_Accounts_User_set_account_type_reply)data->cb) (proxy, error, data->userdata);
377
 
  return;
378
 
}
379
 
 
380
 
static
381
 
#ifdef G_HAVE_INLINE
382
 
inline
383
 
#endif
384
 
DBusGProxyCall*
385
 
org_freedesktop_Accounts_User_set_account_type_async (DBusGProxy *proxy, const gint IN_accountType, org_freedesktop_Accounts_User_set_account_type_reply callback, gpointer userdata)
386
 
 
387
 
{
388
 
  DBusGAsyncData *stuff;
389
 
  stuff = g_slice_new (DBusGAsyncData);
390
 
  stuff->cb = G_CALLBACK (callback);
391
 
  stuff->userdata = userdata;
392
 
  return dbus_g_proxy_begin_call (proxy, "SetAccountType", org_freedesktop_Accounts_User_set_account_type_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_accountType, G_TYPE_INVALID);
393
 
}
394
 
static
395
 
#ifdef G_HAVE_INLINE
396
 
inline
397
 
#endif
398
 
gboolean
399
 
org_freedesktop_Accounts_User_set_password_mode (DBusGProxy *proxy, const gint IN_mode, GError **error)
400
 
 
401
 
{
402
 
  return dbus_g_proxy_call (proxy, "SetPasswordMode", error, G_TYPE_INT, IN_mode, G_TYPE_INVALID, G_TYPE_INVALID);
403
 
}
404
 
 
405
 
typedef void (*org_freedesktop_Accounts_User_set_password_mode_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
406
 
 
407
 
static void
408
 
org_freedesktop_Accounts_User_set_password_mode_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
409
 
{
410
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
411
 
  GError *error = NULL;
412
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
413
 
  (*(org_freedesktop_Accounts_User_set_password_mode_reply)data->cb) (proxy, error, data->userdata);
414
 
  return;
415
 
}
416
 
 
417
 
static
418
 
#ifdef G_HAVE_INLINE
419
 
inline
420
 
#endif
421
 
DBusGProxyCall*
422
 
org_freedesktop_Accounts_User_set_password_mode_async (DBusGProxy *proxy, const gint IN_mode, org_freedesktop_Accounts_User_set_password_mode_reply callback, gpointer userdata)
423
 
 
424
 
{
425
 
  DBusGAsyncData *stuff;
426
 
  stuff = g_slice_new (DBusGAsyncData);
427
 
  stuff->cb = G_CALLBACK (callback);
428
 
  stuff->userdata = userdata;
429
 
  return dbus_g_proxy_begin_call (proxy, "SetPasswordMode", org_freedesktop_Accounts_User_set_password_mode_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT, IN_mode, G_TYPE_INVALID);
430
 
}
431
 
static
432
 
#ifdef G_HAVE_INLINE
433
 
inline
434
 
#endif
435
 
gboolean
436
 
org_freedesktop_Accounts_User_set_password (DBusGProxy *proxy, const char * IN_password, const char * IN_hint, GError **error)
437
 
 
438
 
{
439
 
  return dbus_g_proxy_call (proxy, "SetPassword", error, G_TYPE_STRING, IN_password, G_TYPE_STRING, IN_hint, G_TYPE_INVALID, G_TYPE_INVALID);
440
 
}
441
 
 
442
 
typedef void (*org_freedesktop_Accounts_User_set_password_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
443
 
 
444
 
static void
445
 
org_freedesktop_Accounts_User_set_password_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
446
 
{
447
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
448
 
  GError *error = NULL;
449
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
450
 
  (*(org_freedesktop_Accounts_User_set_password_reply)data->cb) (proxy, error, data->userdata);
451
 
  return;
452
 
}
453
 
 
454
 
static
455
 
#ifdef G_HAVE_INLINE
456
 
inline
457
 
#endif
458
 
DBusGProxyCall*
459
 
org_freedesktop_Accounts_User_set_password_async (DBusGProxy *proxy, const char * IN_password, const char * IN_hint, org_freedesktop_Accounts_User_set_password_reply callback, gpointer userdata)
460
 
 
461
 
{
462
 
  DBusGAsyncData *stuff;
463
 
  stuff = g_slice_new (DBusGAsyncData);
464
 
  stuff->cb = G_CALLBACK (callback);
465
 
  stuff->userdata = userdata;
466
 
  return dbus_g_proxy_begin_call (proxy, "SetPassword", org_freedesktop_Accounts_User_set_password_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_password, G_TYPE_STRING, IN_hint, G_TYPE_INVALID);
467
 
}
468
 
static
469
 
#ifdef G_HAVE_INLINE
470
 
inline
471
 
#endif
472
 
gboolean
473
 
org_freedesktop_Accounts_User_set_automatic_login (DBusGProxy *proxy, const gboolean IN_enabled, GError **error)
474
 
 
475
 
{
476
 
  return dbus_g_proxy_call (proxy, "SetAutomaticLogin", error, G_TYPE_BOOLEAN, IN_enabled, G_TYPE_INVALID, G_TYPE_INVALID);
477
 
}
478
 
 
479
 
typedef void (*org_freedesktop_Accounts_User_set_automatic_login_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
480
 
 
481
 
static void
482
 
org_freedesktop_Accounts_User_set_automatic_login_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
483
 
{
484
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
485
 
  GError *error = NULL;
486
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
487
 
  (*(org_freedesktop_Accounts_User_set_automatic_login_reply)data->cb) (proxy, error, data->userdata);
488
 
  return;
489
 
}
490
 
 
491
 
static
492
 
#ifdef G_HAVE_INLINE
493
 
inline
494
 
#endif
495
 
DBusGProxyCall*
496
 
org_freedesktop_Accounts_User_set_automatic_login_async (DBusGProxy *proxy, const gboolean IN_enabled, org_freedesktop_Accounts_User_set_automatic_login_reply callback, gpointer userdata)
497
 
 
498
 
{
499
 
  DBusGAsyncData *stuff;
500
 
  stuff = g_slice_new (DBusGAsyncData);
501
 
  stuff->cb = G_CALLBACK (callback);
502
 
  stuff->userdata = userdata;
503
 
  return dbus_g_proxy_begin_call (proxy, "SetAutomaticLogin", org_freedesktop_Accounts_User_set_automatic_login_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_BOOLEAN, IN_enabled, G_TYPE_INVALID);
504
 
}
505
 
#endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_Accounts_User */
506
 
 
507
 
G_END_DECLS