← Back to branch summary

~skypce/indicator-session/indicator-session

« back to all changes in this revision

Viewing changes to src/accounts-service-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:
src/accounts-service-client.h
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
22
 
#define DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_Accounts
23
 
 
24
 
static
25
 
#ifdef G_HAVE_INLINE
26
 
inline
27
 
#endif
28
 
gboolean
29
 
org_freedesktop_Accounts_list_cached_users (DBusGProxy *proxy, GPtrArray** OUT_users, GError **error)
30
 
 
31
 
{
32
 
  return dbus_g_proxy_call (proxy, "ListCachedUsers", error, G_TYPE_INVALID, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), OUT_users, G_TYPE_INVALID);
33
 
}
34
 
 
35
 
typedef void (*org_freedesktop_Accounts_list_cached_users_reply) (DBusGProxy *proxy, GPtrArray *OUT_users, GError *error, gpointer userdata);
36
 
 
37
 
static void
38
 
org_freedesktop_Accounts_list_cached_users_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
39
 
{
40
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
41
 
  GError *error = NULL;
42
 
  GPtrArray* OUT_users;
43
 
  dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &OUT_users, G_TYPE_INVALID);
44
 
  (*(org_freedesktop_Accounts_list_cached_users_reply)data->cb) (proxy, OUT_users, error, data->userdata);
45
 
  return;
46
 
}
47
 
 
48
 
static
49
 
#ifdef G_HAVE_INLINE
50
 
inline
51
 
#endif
52
 
DBusGProxyCall*
53
 
org_freedesktop_Accounts_list_cached_users_async (DBusGProxy *proxy, org_freedesktop_Accounts_list_cached_users_reply callback, gpointer userdata)
54
 
 
55
 
{
56
 
  DBusGAsyncData *stuff;
57
 
  stuff = g_slice_new (DBusGAsyncData);
58
 
  stuff->cb = G_CALLBACK (callback);
59
 
  stuff->userdata = userdata;
60
 
  return dbus_g_proxy_begin_call (proxy, "ListCachedUsers", org_freedesktop_Accounts_list_cached_users_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INVALID);
61
 
}
62
 
static
63
 
#ifdef G_HAVE_INLINE
64
 
inline
65
 
#endif
66
 
gboolean
67
 
org_freedesktop_Accounts_find_user_by_id (DBusGProxy *proxy, const gint64 IN_id, char** OUT_user, GError **error)
68
 
 
69
 
{
70
 
  return dbus_g_proxy_call (proxy, "FindUserById", error, G_TYPE_INT64, IN_id, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_user, G_TYPE_INVALID);
71
 
}
72
 
 
73
 
typedef void (*org_freedesktop_Accounts_find_user_by_id_reply) (DBusGProxy *proxy, char *OUT_user, GError *error, gpointer userdata);
74
 
 
75
 
static void
76
 
org_freedesktop_Accounts_find_user_by_id_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
77
 
{
78
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
79
 
  GError *error = NULL;
80
 
  char* OUT_user;
81
 
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_user, G_TYPE_INVALID);
82
 
  (*(org_freedesktop_Accounts_find_user_by_id_reply)data->cb) (proxy, OUT_user, error, data->userdata);
83
 
  return;
84
 
}
85
 
 
86
 
static
87
 
#ifdef G_HAVE_INLINE
88
 
inline
89
 
#endif
90
 
DBusGProxyCall*
91
 
org_freedesktop_Accounts_find_user_by_id_async (DBusGProxy *proxy, const gint64 IN_id, org_freedesktop_Accounts_find_user_by_id_reply callback, gpointer userdata)
92
 
 
93
 
{
94
 
  DBusGAsyncData *stuff;
95
 
  stuff = g_slice_new (DBusGAsyncData);
96
 
  stuff->cb = G_CALLBACK (callback);
97
 
  stuff->userdata = userdata;
98
 
  return dbus_g_proxy_begin_call (proxy, "FindUserById", org_freedesktop_Accounts_find_user_by_id_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT64, IN_id, G_TYPE_INVALID);
99
 
}
100
 
static
101
 
#ifdef G_HAVE_INLINE
102
 
inline
103
 
#endif
104
 
gboolean
105
 
org_freedesktop_Accounts_find_user_by_name (DBusGProxy *proxy, const char * IN_name, char** OUT_user, GError **error)
106
 
 
107
 
{
108
 
  return dbus_g_proxy_call (proxy, "FindUserByName", error, G_TYPE_STRING, IN_name, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_user, G_TYPE_INVALID);
109
 
}
110
 
 
111
 
typedef void (*org_freedesktop_Accounts_find_user_by_name_reply) (DBusGProxy *proxy, char *OUT_user, GError *error, gpointer userdata);
112
 
 
113
 
static void
114
 
org_freedesktop_Accounts_find_user_by_name_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
115
 
{
116
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
117
 
  GError *error = NULL;
118
 
  char* OUT_user;
119
 
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_user, G_TYPE_INVALID);
120
 
  (*(org_freedesktop_Accounts_find_user_by_name_reply)data->cb) (proxy, OUT_user, error, data->userdata);
121
 
  return;
122
 
}
123
 
 
124
 
static
125
 
#ifdef G_HAVE_INLINE
126
 
inline
127
 
#endif
128
 
DBusGProxyCall*
129
 
org_freedesktop_Accounts_find_user_by_name_async (DBusGProxy *proxy, const char * IN_name, org_freedesktop_Accounts_find_user_by_name_reply callback, gpointer userdata)
130
 
 
131
 
{
132
 
  DBusGAsyncData *stuff;
133
 
  stuff = g_slice_new (DBusGAsyncData);
134
 
  stuff->cb = G_CALLBACK (callback);
135
 
  stuff->userdata = userdata;
136
 
  return dbus_g_proxy_begin_call (proxy, "FindUserByName", org_freedesktop_Accounts_find_user_by_name_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_name, G_TYPE_INVALID);
137
 
}
138
 
static
139
 
#ifdef G_HAVE_INLINE
140
 
inline
141
 
#endif
142
 
gboolean
143
 
org_freedesktop_Accounts_create_user (DBusGProxy *proxy, const char * IN_name, const char * IN_fullname, const gint IN_accountType, char** OUT_user, GError **error)
144
 
 
145
 
{
146
 
  return dbus_g_proxy_call (proxy, "CreateUser", error, G_TYPE_STRING, IN_name, G_TYPE_STRING, IN_fullname, G_TYPE_INT, IN_accountType, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, OUT_user, G_TYPE_INVALID);
147
 
}
148
 
 
149
 
typedef void (*org_freedesktop_Accounts_create_user_reply) (DBusGProxy *proxy, char *OUT_user, GError *error, gpointer userdata);
150
 
 
151
 
static void
152
 
org_freedesktop_Accounts_create_user_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
153
 
{
154
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
155
 
  GError *error = NULL;
156
 
  char* OUT_user;
157
 
  dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &OUT_user, G_TYPE_INVALID);
158
 
  (*(org_freedesktop_Accounts_create_user_reply)data->cb) (proxy, OUT_user, error, data->userdata);
159
 
  return;
160
 
}
161
 
 
162
 
static
163
 
#ifdef G_HAVE_INLINE
164
 
inline
165
 
#endif
166
 
DBusGProxyCall*
167
 
org_freedesktop_Accounts_create_user_async (DBusGProxy *proxy, const char * IN_name, const char * IN_fullname, const gint IN_accountType, org_freedesktop_Accounts_create_user_reply callback, gpointer userdata)
168
 
 
169
 
{
170
 
  DBusGAsyncData *stuff;
171
 
  stuff = g_slice_new (DBusGAsyncData);
172
 
  stuff->cb = G_CALLBACK (callback);
173
 
  stuff->userdata = userdata;
174
 
  return dbus_g_proxy_begin_call (proxy, "CreateUser", org_freedesktop_Accounts_create_user_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_STRING, IN_name, G_TYPE_STRING, IN_fullname, G_TYPE_INT, IN_accountType, G_TYPE_INVALID);
175
 
}
176
 
static
177
 
#ifdef G_HAVE_INLINE
178
 
inline
179
 
#endif
180
 
gboolean
181
 
org_freedesktop_Accounts_delete_user (DBusGProxy *proxy, const gint64 IN_id, const gboolean IN_removeFiles, GError **error)
182
 
 
183
 
{
184
 
  return dbus_g_proxy_call (proxy, "DeleteUser", error, G_TYPE_INT64, IN_id, G_TYPE_BOOLEAN, IN_removeFiles, G_TYPE_INVALID, G_TYPE_INVALID);
185
 
}
186
 
 
187
 
typedef void (*org_freedesktop_Accounts_delete_user_reply) (DBusGProxy *proxy, GError *error, gpointer userdata);
188
 
 
189
 
static void
190
 
org_freedesktop_Accounts_delete_user_async_callback (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data)
191
 
{
192
 
  DBusGAsyncData *data = (DBusGAsyncData*) user_data;
193
 
  GError *error = NULL;
194
 
  dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
195
 
  (*(org_freedesktop_Accounts_delete_user_reply)data->cb) (proxy, error, data->userdata);
196
 
  return;
197
 
}
198
 
 
199
 
static
200
 
#ifdef G_HAVE_INLINE
201
 
inline
202
 
#endif
203
 
DBusGProxyCall*
204
 
org_freedesktop_Accounts_delete_user_async (DBusGProxy *proxy, const gint64 IN_id, const gboolean IN_removeFiles, org_freedesktop_Accounts_delete_user_reply callback, gpointer userdata)
205
 
 
206
 
{
207
 
  DBusGAsyncData *stuff;
208
 
  stuff = g_slice_new (DBusGAsyncData);
209
 
  stuff->cb = G_CALLBACK (callback);
210
 
  stuff->userdata = userdata;
211
 
  return dbus_g_proxy_begin_call (proxy, "DeleteUser", org_freedesktop_Accounts_delete_user_async_callback, stuff, _dbus_glib_async_data_free, G_TYPE_INT64, IN_id, G_TYPE_BOOLEAN, IN_removeFiles, G_TYPE_INVALID);
212
 
}
213
 
#endif /* defined DBUS_GLIB_CLIENT_WRAPPERS_org_freedesktop_Accounts */
214
 
 
215
 
G_END_DECLS