← Back to branch summary

~ubuntu-branches/ubuntu/precise/evolution-data-server/precise

« back to all changes in this revision

Viewing changes to libedataserver/e-gdbus-templates.h

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre, Ken VanDine, Mathieu Trudel-Lapierre
  • Date: 2011-06-23 17:40:41 UTC
  • mfrom: (1.1.88 upstream)
  • Revision ID: james.westby@ubuntu.com-20110623174041-4wd9jvs07wfinyet
Tags: 3.1.2-0ubuntu1
https://launchpad.net/bugs/385859
https://launchpad.net/bugs/781391
https://launchpad.net/bugs/160304
* New upstream version
  - bgo 589495 - Search folder by Size (KB) counts bytes, not KB (LP: #385859)
  - bgo 649757 - Filtering on a source account always succeeded (LP: #781391)
  - bgo 418954 - Add a separate entry combo for port numbers (LP: #160304)

[ Ken VanDine ]
* debian/libebook1.2-dev.install
  - Include EBook-1.2.gir
* debian/control
  - Added gir1.2-ebook-1.2 binary

[ Mathieu Trudel-Lapierre ]
* debian/control: drop libegroupwise1.2-13, libegroupwise-dev, they are now
  an independent module.
* debian/libegroupwise1.2-13.install,
  debian/libegroupwise1.2-dev.install,
  debian/lintian/libegroupwise1.2-13: dropped, see above.
* debian/control, debian/libe*.install, debian/lintian/libe*: rename and
  update files where needed to follow upstream soname changes.
* debian/control: bump evolution-data-server's Depends to libcamel-1.2-26.
* debian/rules: update to use makeshlibs with the new libcamel soname.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libedataserver/e-gdbus-templates.h
 
1
/*
 
2
 * e-gdbus-templates.h
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2 of the License, or (at your option) version 3.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 
16
 *
 
17
 *
 
18
 * Copyright (C) 2011 Red Hat, Inc. (www.redhat.com)
 
19
 *
 
20
 */
 
21
 
 
22
#ifndef E_GDBUS_TEMPLATES_H
 
23
#define E_GDBUS_TEMPLATES_H
 
24
 
 
25
#include <gio/gio.h>
 
26
#include <libedataserver/e-gdbus-marshallers.h>
 
27
 
 
28
G_BEGIN_DECLS
 
29
 
 
30
#define E_TYPE_GDBUS_ASYNC_OP_KEEPER            (e_gdbus_async_op_keeper_get_type ())
 
31
#define E_GDBUS_ASYNC_OP_KEEPER(o)              (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TYPE_GDBUS_ASYNC_OP_KEEPER, EGdbusAsyncOpKeeper))
 
32
#define E_IS_GDBUS_ASYNC_OP_KEEPER(o)           (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TYPE_GDBUS_ASYNC_OP_KEEPER))
 
33
#define E_GDBUS_ASYNC_OP_KEEPER_GET_IFACE(o)    (G_TYPE_INSTANCE_GET_INTERFACE((o), E_TYPE_GDBUS_ASYNC_OP_KEEPER, EGdbusAsyncOpKeeperInterface))
 
34
 
 
35
typedef struct _EGdbusAsyncOpKeeper EGdbusAsyncOpKeeper; /* Dummy typedef */
 
36
typedef struct _EGdbusAsyncOpKeeperInterface EGdbusAsyncOpKeeperInterface;
 
37
 
 
38
struct _EGdbusAsyncOpKeeperInterface
 
39
{
 
40
        GTypeInterface parent_iface;
 
41
 
 
42
        GHashTable *    (* get_pending_ops)     (EGdbusAsyncOpKeeper *object);
 
43
        gboolean        (* cancel_op_sync)      (EGdbusAsyncOpKeeper *object, guint in_opid, GCancellable *cancellable, GError **error);
 
44
};
 
45
 
 
46
GType e_gdbus_async_op_keeper_get_type (void) G_GNUC_CONST;
 
47
 
 
48
GHashTable *    e_gdbus_async_op_keeper_create_pending_ops      (EGdbusAsyncOpKeeper *object);
 
49
GHashTable *    e_gdbus_async_op_keeper_get_pending_ops         (EGdbusAsyncOpKeeper *object);
 
50
gboolean        e_gdbus_async_op_keeper_cancel_op_sync          (EGdbusAsyncOpKeeper *object, guint in_opid, GCancellable *cancellable, GError **error);
 
51
 
 
52
enum {
 
53
        E_GDBUS_TYPE_IS_ASYNC   = 1 << 0, /* if set, then OPID and GError precedes to actual parameter */
 
54
        E_GDBUS_TYPE_VOID       = 1 << 1,
 
55
        E_GDBUS_TYPE_BOOLEAN    = 1 << 2,
 
56
        E_GDBUS_TYPE_STRING     = 1 << 3,
 
57
        E_GDBUS_TYPE_STRV       = 1 << 4,
 
58
        E_GDBUS_TYPE_UINT       = 1 << 5
 
59
};
 
60
 
 
61
/* _where is a target component name, like ' ## _where ## ' or 'cal'
 
62
   _mname is method name, like 'open'
 
63
   _mtype is method type, like 'method_in'
 
64
   _param_name is parameter name, like 'only_if_exists'
 
65
   _param_type is parameter type, as string, like "s"
 
66
   all except _param_type are identificators, not strings
 
67
*/
 
68
#define E_DECLARE_GDBUS_ARG(_where, _mname, _mtype, _param_name, _param_type)                           \
 
69
        static const GDBusArgInfo e_gdbus_ ## _where ## _ ## _mtype ## _mname ## _param_name =          \
 
70
        {                                                                                               \
 
71
                -1,                                                                                     \
 
72
                (gchar *) # _param_name,                                                                \
 
73
                (gchar *) _param_type,                                                                  \
 
74
                (GDBusAnnotationInfo **) NULL,                                                          \
 
75
        };
 
76
 
 
77
#define E_DECLARE_GDBUS_NOTIFY_SIGNAL_0(_where, _sname)                                                 \
 
78
        static const GDBusSignalInfo e_gdbus_ ## _where ## _signal_ ## _sname =                         \
 
79
        {                                                                                               \
 
80
                -1,                                                                                     \
 
81
                (gchar *) # _sname,                                                                     \
 
82
                (GDBusArgInfo **) NULL,                                                                 \
 
83
                (GDBusAnnotationInfo **) NULL,                                                          \
 
84
        };
 
85
 
 
86
#define E_DECLARE_GDBUS_NOTIFY_SIGNAL_1(_where, _sname, _p1_name, _p1_type)                             \
 
87
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, _p1_name, _p1_type)                                \
 
88
                                                                                                        \
 
89
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname[] =     \
 
90
        {                                                                                               \
 
91
                &e_gdbus_ ## _where ## _signal ## _sname ## _p1_name,                                   \
 
92
                NULL                                                                                    \
 
93
        };                                                                                              \
 
94
                                                                                                        \
 
95
        static const GDBusSignalInfo e_gdbus_ ## _where ## _signal_ ## _sname =                         \
 
96
        {                                                                                               \
 
97
                -1,                                                                                     \
 
98
                (gchar *) # _sname,                                                                     \
 
99
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname,               \
 
100
                (GDBusAnnotationInfo **) NULL,                                                          \
 
101
        };
 
102
 
 
103
#define E_DECLARE_GDBUS_NOTIFY_SIGNAL_2(_where, _sname, _p1_name, _p1_type, _p2_name, _p2_type)         \
 
104
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, _p1_name, _p1_type)                                \
 
105
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, _p2_name, _p2_type)                                \
 
106
                                                                                                        \
 
107
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname[] =     \
 
108
        {                                                                                               \
 
109
                &e_gdbus_ ## _where ## _signal ## _sname ## _p1_name,                                   \
 
110
                &e_gdbus_ ## _where ## _signal ## _sname ## _p2_name,                                   \
 
111
                NULL                                                                                    \
 
112
        };                                                                                              \
 
113
                                                                                                        \
 
114
        static const GDBusSignalInfo e_gdbus_ ## _where ## _signal_ ## _sname =                         \
 
115
        {                                                                                               \
 
116
                -1,                                                                                     \
 
117
                (gchar *) # _sname,                                                                     \
 
118
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname,               \
 
119
                (GDBusAnnotationInfo **) NULL,                                                          \
 
120
        };
 
121
 
 
122
#define E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_0(_where, _sname)                                             \
 
123
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, opid, "u")                                         \
 
124
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, dbus_error_name, "s")                              \
 
125
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, dbus_error_message, "s")                           \
 
126
                                                                                                        \
 
127
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname[] =     \
 
128
        {                                                                                               \
 
129
                &e_gdbus_ ## _where ## _signal ## _sname ## opid,                                       \
 
130
                &e_gdbus_ ## _where ## _signal ## _sname ## dbus_error_name,                            \
 
131
                &e_gdbus_ ## _where ## _signal ## _sname ## dbus_error_message,                         \
 
132
                NULL                                                                                    \
 
133
        };                                                                                              \
 
134
                                                                                                        \
 
135
        static const GDBusSignalInfo e_gdbus_ ## _where ## _signal_ ## _sname =                         \
 
136
        {                                                                                               \
 
137
                -1,                                                                                     \
 
138
                (gchar *) # _sname,                                                                     \
 
139
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname,               \
 
140
                (GDBusAnnotationInfo **) NULL,                                                          \
 
141
        };
 
142
 
 
143
#define E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_1(_where, _sname, _p1_name, _p1_type)                         \
 
144
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, opid, "u")                                         \
 
145
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, dbus_error_name, "s")                              \
 
146
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, dbus_error_message, "s")                           \
 
147
        E_DECLARE_GDBUS_ARG (_where, _sname, signal, _p1_name, _p1_type)                                \
 
148
                                                                                                        \
 
149
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname[] =     \
 
150
        {                                                                                               \
 
151
                &e_gdbus_ ## _where ## _signal ## _sname ## opid,                                       \
 
152
                &e_gdbus_ ## _where ## _signal ## _sname ## dbus_error_name,                            \
 
153
                &e_gdbus_ ## _where ## _signal ## _sname ## dbus_error_message,                         \
 
154
                &e_gdbus_ ## _where ## _signal ## _sname ## _p1_name,                                   \
 
155
                NULL                                                                                    \
 
156
        };                                                                                              \
 
157
                                                                                                        \
 
158
        static const GDBusSignalInfo e_gdbus_ ## _where ## _signal_ ## _sname =                         \
 
159
        {                                                                                               \
 
160
                -1,                                                                                     \
 
161
                (gchar *) # _sname,                                                                     \
 
162
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _signal_arg_pointers_ ## _sname,               \
 
163
                (GDBusAnnotationInfo **) NULL,                                                          \
 
164
        };
 
165
 
 
166
#define E_DECLARE_GDBUS_SYNC_METHOD_0(_where, _mname)                                                   \
 
167
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
168
        {                                                                                               \
 
169
                -1,                                                                                     \
 
170
                (gchar *) # _mname,                                                                     \
 
171
                (GDBusArgInfo **) NULL,                                                                 \
 
172
                (GDBusArgInfo **) NULL,                                                                 \
 
173
                (GDBusAnnotationInfo **) NULL,                                                          \
 
174
        };
 
175
 
 
176
#define E_DECLARE_GDBUS_SYNC_METHOD_1(_where, _mname, _p1_name, _p1_type)                               \
 
177
        E_DECLARE_GDBUS_ARG (_where, _mname, method_in, _p1_name, _p1_type)                             \
 
178
                                                                                                        \
 
179
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname[] =  \
 
180
        {                                                                                               \
 
181
                &e_gdbus_ ## _where ## _method_in ## _mname ## _p1_name,                                \
 
182
                NULL                                                                                    \
 
183
        };                                                                                              \
 
184
                                                                                                        \
 
185
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
186
        {                                                                                               \
 
187
                -1,                                                                                     \
 
188
                (gchar *) # _mname,                                                                     \
 
189
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname,            \
 
190
                (GDBusArgInfo **) NULL,                                                                 \
 
191
                (GDBusAnnotationInfo **) NULL,                                                          \
 
192
        };
 
193
 
 
194
#define E_DECLARE_GDBUS_SYNC_METHOD_0_WITH_RETURN(_where, _mname, _r1_name, _r1_type)                   \
 
195
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, _r1_name, _r1_type)                            \
 
196
                                                                                                        \
 
197
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
198
        {                                                                                               \
 
199
                &e_gdbus_ ## _where ## _method_out ## _mname ## _r1_name,                               \
 
200
                NULL                                                                                    \
 
201
        };                                                                                              \
 
202
                                                                                                        \
 
203
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
204
        {                                                                                               \
 
205
                -1,                                                                                     \
 
206
                (gchar *) # _mname,                                                                     \
 
207
                (GDBusArgInfo **) NULL,                                                                 \
 
208
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
209
                (GDBusAnnotationInfo **) NULL,                                                          \
 
210
        };
 
211
 
 
212
#define E_DECLARE_GDBUS_SYNC_METHOD_1_WITH_RETURN(_where, _mname, _p1_name, _p1_type, _r1_name, _r1_type)\
 
213
        E_DECLARE_GDBUS_ARG (_where, _mname, method_in, _p1_name, _p1_type)                             \
 
214
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, _r1_name, _r1_type)                            \
 
215
                                                                                                        \
 
216
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname[] =  \
 
217
        {                                                                                               \
 
218
                &e_gdbus_ ## _where ## _method_in ## _mname ## _p1_name,                                \
 
219
                NULL                                                                                    \
 
220
        };                                                                                              \
 
221
                                                                                                        \
 
222
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
223
        {                                                                                               \
 
224
                &e_gdbus_ ## _where ## _method_out ## _mname ## _r1_name,                               \
 
225
                NULL                                                                                    \
 
226
        };                                                                                              \
 
227
                                                                                                        \
 
228
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
229
        {                                                                                               \
 
230
                -1,                                                                                     \
 
231
                (gchar *) # _mname,                                                                     \
 
232
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname,            \
 
233
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
234
                (GDBusAnnotationInfo **) NULL,                                                          \
 
235
        };
 
236
 
 
237
#define E_DECLARE_GDBUS_ASYNC_METHOD_0(_where, _mname)                                                  \
 
238
        E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_0 (_where, _mname ## _done)                                   \
 
239
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, opid, "u")                                     \
 
240
                                                                                                        \
 
241
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
242
        {                                                                                               \
 
243
                &e_gdbus_ ## _where ## _method_out ## _mname ## opid,                                   \
 
244
                NULL                                                                                    \
 
245
        };                                                                                              \
 
246
                                                                                                        \
 
247
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
248
        {                                                                                               \
 
249
                -1,                                                                                     \
 
250
                (gchar *) # _mname,                                                                     \
 
251
                (GDBusArgInfo **) NULL,                                                                 \
 
252
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
253
                (GDBusAnnotationInfo **) NULL,                                                          \
 
254
        };
 
255
 
 
256
#define E_DECLARE_GDBUS_ASYNC_METHOD_1(_where, _mname, _p1_name, _p1_type)                              \
 
257
        E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_0 (_where, _mname ## _done)                                   \
 
258
        E_DECLARE_GDBUS_ARG (_where, _mname, method_in, _p1_name, _p1_type)                             \
 
259
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, opid, "u")                                     \
 
260
                                                                                                        \
 
261
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname[] =  \
 
262
        {                                                                                               \
 
263
                &e_gdbus_ ## _where ## _method_in ## _mname ## _p1_name,                                \
 
264
                NULL                                                                                    \
 
265
        };                                                                                              \
 
266
                                                                                                        \
 
267
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
268
        {                                                                                               \
 
269
                &e_gdbus_ ## _where ## _method_out ## _mname ## opid,                                   \
 
270
                NULL                                                                                    \
 
271
        };                                                                                              \
 
272
                                                                                                        \
 
273
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
274
        {                                                                                               \
 
275
                -1,                                                                                     \
 
276
                (gchar *) # _mname,                                                                     \
 
277
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname,            \
 
278
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
279
                (GDBusAnnotationInfo **) NULL,                                                          \
 
280
        };
 
281
 
 
282
#define E_DECLARE_GDBUS_ASYNC_METHOD_0_WITH_RETURN(_where, _mname, _r1_name, _r1_type)                  \
 
283
        E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_1 (_where, _mname ## _done, _r1_name, _r1_type)               \
 
284
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, opid, "u")                                     \
 
285
                                                                                                        \
 
286
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
287
        {                                                                                               \
 
288
                &e_gdbus_ ## _where ## _method_out ## _mname ## opid,                                   \
 
289
                NULL                                                                                    \
 
290
        };                                                                                              \
 
291
                                                                                                        \
 
292
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
293
        {                                                                                               \
 
294
                -1,                                                                                     \
 
295
                (gchar *) # _mname,                                                                     \
 
296
                (GDBusArgInfo **) NULL,                                                                 \
 
297
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
298
                (GDBusAnnotationInfo **) NULL,                                                          \
 
299
        };
 
300
 
 
301
#define E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN(_where, _mname, _p1_name, _p1_type, _r1_name, _r1_type)\
 
302
        E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_1 (_where, _mname ## _done, _r1_name, _r1_type)               \
 
303
        E_DECLARE_GDBUS_ARG (_where, _mname, method_in, _p1_name, _p1_type)                             \
 
304
        E_DECLARE_GDBUS_ARG (_where, _mname, method_out, opid, "u")                                     \
 
305
                                                                                                        \
 
306
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname[] =  \
 
307
        {                                                                                               \
 
308
                &e_gdbus_ ## _where ## _method_in ## _mname ## _p1_name,                                \
 
309
                NULL                                                                                    \
 
310
        };                                                                                              \
 
311
                                                                                                        \
 
312
        static const GDBusArgInfo * const e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname[] = \
 
313
        {                                                                                               \
 
314
                &e_gdbus_ ## _where ## _method_out ## _mname ## opid,                                   \
 
315
                NULL                                                                                    \
 
316
        };                                                                                              \
 
317
                                                                                                        \
 
318
        static const GDBusMethodInfo e_gdbus_ ## _where ## _method_ ## _mname =                         \
 
319
        {                                                                                               \
 
320
                -1,                                                                                     \
 
321
                (gchar *) # _mname,                                                                     \
 
322
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_in_arg_pointers_ ## _mname,            \
 
323
                (GDBusArgInfo **) &e_gdbus_ ## _where ## _method_out_arg_pointers_ ## _mname,           \
 
324
                (GDBusAnnotationInfo **) NULL,                                                          \
 
325
        };
 
326
 
 
327
#define E_DECLARED_GDBUS_SIGNAL_INFO_NAME(_where, _sname) e_gdbus_ ## _where ## _signal_ ## _sname
 
328
#define E_DECLARED_GDBUS_METHOD_INFO_NAME(_where, _mname) e_gdbus_ ## _where ## _method_ ## _mname
 
329
 
 
330
/* this requires signal_emission_hook_cb_ ## _sig_name hook defined,
 
331
   which can be created with one of E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_... macros */
 
332
#define E_INIT_GDBUS_SIGNAL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                                     \
 
333
        signals[_sig_id] = g_signal_new (# _sig_name_var,                                                                       \
 
334
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
335
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
336
                        G_STRUCT_OFFSET (_iface_struct, _sig_name_var),                                                         \
 
337
                        NULL,                                                                                                   \
 
338
                        NULL,                                                                                                   \
 
339
                        g_cclosure_marshal_VOID__VOID,                                                                          \
 
340
                        G_TYPE_NONE,                                                                                            \
 
341
                        0);                                                                                                     \
 
342
                                                                                                                                \
 
343
        g_signal_add_emission_hook (signals[_sig_id], 0, signal_emission_hook_cb_ ## _sig_name_var, (gpointer) _dbus_sig_name_str, NULL);\
 
344
        g_hash_table_insert (_signal_name_to_id, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (_sig_id));                    \
 
345
        g_hash_table_insert (_signal_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_VOID));
 
346
 
 
347
#define E_INIT_GDBUS_SIGNAL_TMPL_TYPED(_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)               \
 
348
        signals[_sig_id] = g_signal_new (# _sig_name_var,                                                                       \
 
349
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
350
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
351
                        G_STRUCT_OFFSET (_iface_struct, _sig_name_var),                                                         \
 
352
                        NULL,                                                                                                   \
 
353
                        NULL,                                                                                                   \
 
354
                        g_cclosure_marshal_VOID__ ## _mtype,                                                                    \
 
355
                        G_TYPE_NONE,                                                                                            \
 
356
                        1,                                                                                                      \
 
357
                        G_TYPE_ ## _gtype);                                                                                     \
 
358
                                                                                                                                \
 
359
        g_signal_add_emission_hook (signals[_sig_id], 0, signal_emission_hook_cb_ ## _sig_name_var, (gpointer) _dbus_sig_name_str, NULL);\
 
360
        g_hash_table_insert (_signal_name_to_id, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (_sig_id));                    \
 
361
        g_hash_table_insert (_signal_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_ ## _gtype));
 
362
 
 
363
#define E_INIT_GDBUS_SIGNAL_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                                  \
 
364
        E_INIT_GDBUS_SIGNAL_TMPL_TYPED (BOOLEAN, BOOLEAN, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)
 
365
 
 
366
#define E_INIT_GDBUS_SIGNAL_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                                   \
 
367
        E_INIT_GDBUS_SIGNAL_TMPL_TYPED (STRING, STRING, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)
 
368
 
 
369
#define E_INIT_GDBUS_SIGNAL_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                                     \
 
370
        E_INIT_GDBUS_SIGNAL_TMPL_TYPED (BOXED, STRV, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)
 
371
 
 
372
#define E_INIT_GDBUS_SIGNAL_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                                     \
 
373
        E_INIT_GDBUS_SIGNAL_TMPL_TYPED (UINT, UINT, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)
 
374
 
 
375
#define E_INIT_GDBUS_SIGNAL_UINT_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)                              \
 
376
        signals[_sig_id] = g_signal_new (# _sig_name_var,                                                                       \
 
377
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
378
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
379
                        G_STRUCT_OFFSET (_iface_struct, _sig_name_var),                                                         \
 
380
                        NULL,                                                                                                   \
 
381
                        NULL,                                                                                                   \
 
382
                        e_gdbus_marshallers_VOID__UINT_STRING,                                                                  \
 
383
                        G_TYPE_NONE,                                                                                            \
 
384
                        2,                                                                                                      \
 
385
                        G_TYPE_UINT, G_TYPE_STRING);                                                                            \
 
386
                                                                                                                                \
 
387
        g_signal_add_emission_hook (signals[_sig_id], 0, signal_emission_hook_cb_ ## _sig_name_var, (gpointer) _dbus_sig_name_str, NULL);\
 
388
        g_hash_table_insert (_signal_name_to_id, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (_sig_id));                    \
 
389
        g_hash_table_insert (_signal_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_UINT | E_GDBUS_TYPE_STRING));
 
390
 
 
391
#define E_INIT_GDBUS_METHOD_DONE_VOID(_iface_struct, _sig_name_var, _done_sig_id)                                               \
 
392
        signals[_done_sig_id] = g_signal_new (# _sig_name_var "_done",                                                          \
 
393
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
394
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
395
                        G_STRUCT_OFFSET (_iface_struct, _sig_name_var ## _done),                                                \
 
396
                        NULL,                                                                                                   \
 
397
                        NULL,                                                                                                   \
 
398
                        e_gdbus_marshallers_VOID__UINT_BOXED,                                                                   \
 
399
                        G_TYPE_NONE,                                                                                            \
 
400
                        2,                                                                                                      \
 
401
                        G_TYPE_UINT, G_TYPE_ERROR);                                                                             \
 
402
        g_signal_add_emission_hook (signals[_done_sig_id], 0,                                                                   \
 
403
                        signal_emission_hook_cb_ ## _sig_name_var ## _done, (gpointer) # _sig_name_var "_done", NULL);          \
 
404
        g_hash_table_insert (_signal_name_to_id, (gpointer) # _sig_name_var "_done", GUINT_TO_POINTER (_done_sig_id));          \
 
405
        g_hash_table_insert (_signal_name_to_type, (gpointer) # _sig_name_var "_done", GUINT_TO_POINTER (E_GDBUS_TYPE_IS_ASYNC | E_GDBUS_TYPE_VOID));
 
406
 
 
407
#define E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED(_mtype, _gtype, _iface_struct, _sig_name_var, _done_sig_id)                   \
 
408
        signals[_done_sig_id] = g_signal_new (# _sig_name_var "_done",                                                          \
 
409
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
410
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
411
                        G_STRUCT_OFFSET (_iface_struct, _sig_name_var ## _done),                                                \
 
412
                        NULL,                                                                                                   \
 
413
                        NULL,                                                                                                   \
 
414
                        e_gdbus_marshallers_VOID__UINT_BOXED_ ## _mtype,                                                        \
 
415
                        G_TYPE_NONE,                                                                                            \
 
416
                        3,                                                                                                      \
 
417
                        G_TYPE_UINT, G_TYPE_ERROR, G_TYPE_ ## _gtype);                                                          \
 
418
        g_signal_add_emission_hook (signals[_done_sig_id], 0,                                                                   \
 
419
                        signal_emission_hook_cb_ ## _sig_name_var ## _done, (gpointer) # _sig_name_var "_done", NULL);          \
 
420
        g_hash_table_insert (_signal_name_to_id, (gpointer) # _sig_name_var "_done", GUINT_TO_POINTER (_done_sig_id));          \
 
421
        g_hash_table_insert (_signal_name_to_type, (gpointer) # _sig_name_var "_done", GUINT_TO_POINTER (E_GDBUS_TYPE_IS_ASYNC | E_GDBUS_TYPE_ ## _gtype));
 
422
 
 
423
#define E_INIT_GDBUS_METHOD_DONE_BOOLEAN(_iface_struct, _sig_name_var, _done_sig_id)                                            \
 
424
        E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED (BOOLEAN, BOOLEAN, _iface_struct, _sig_name_var, _done_sig_id)
 
425
 
 
426
#define E_INIT_GDBUS_METHOD_DONE_STRING(_iface_struct, _sig_name_var, _done_sig_id)                                             \
 
427
        E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED (STRING, STRING, _iface_struct, _sig_name_var, _done_sig_id)
 
428
 
 
429
#define E_INIT_GDBUS_METHOD_DONE_STRV(_iface_struct, _sig_name_var, _done_sig_id)                                               \
 
430
        E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED (BOXED, STRV, _iface_struct, _sig_name_var, _done_sig_id)
 
431
 
 
432
#define E_INIT_GDBUS_METHOD_DONE_UINT(_iface_struct, _sig_name_var, _done_sig_id)                                               \
 
433
        E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED (UINT, UINT, _iface_struct, _sig_name_var, _done_sig_id)
 
434
 
 
435
/* do not use this directly, there is missing _method_name_to_type insertion */
 
436
#define E_INIT_GDBUS_METHOD_CALL_TMPL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                    \
 
437
        signals[_method_sig_id] = g_signal_new ("handle-" # _sig_name_var,                                                      \
 
438
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
439
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
440
                        G_STRUCT_OFFSET (_iface_struct, handle_ ## _sig_name_var),                                              \
 
441
                        NULL, NULL,                                                                                             \
 
442
                        e_gdbus_marshallers_BOOLEAN__OBJECT,                                                                    \
 
443
                        G_TYPE_BOOLEAN,                                                                                         \
 
444
                        1,                                                                                                      \
 
445
                        G_TYPE_DBUS_METHOD_INVOCATION);                                                                         \
 
446
        g_hash_table_insert (_method_name_to_id, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (_method_sig_id));
 
447
 
 
448
/* do not use this directly, there is missing _method_name_to_type insertion */
 
449
#define E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED(_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)   \
 
450
        signals[_method_sig_id] = g_signal_new ("handle-" # _sig_name_var,                                                      \
 
451
                        G_TYPE_FROM_INTERFACE (iface),                                                                          \
 
452
                        G_SIGNAL_RUN_LAST,                                                                                      \
 
453
                        G_STRUCT_OFFSET (_iface_struct, handle_ ## _sig_name_var),                                              \
 
454
                        NULL, NULL,                                                                                             \
 
455
                        e_gdbus_marshallers_BOOLEAN__OBJECT_ ## _mtype,                                                         \
 
456
                        G_TYPE_BOOLEAN,                                                                                         \
 
457
                        2,                                                                                                      \
 
458
                        G_TYPE_DBUS_METHOD_INVOCATION,                                                                          \
 
459
                        G_TYPE_ ## _gtype);                                                                                     \
 
460
        g_hash_table_insert (_method_name_to_id, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (_method_sig_id));             \
 
461
 
 
462
#define E_INIT_GDBUS_METHOD_CALL_ASYNC_TMPL_TYPED(_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)     \
 
463
        E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED (_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)  \
 
464
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_ ## _gtype | E_GDBUS_TYPE_IS_ASYNC));
 
465
 
 
466
#define E_INIT_GDBUS_METHOD_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                              \
 
467
        E_INIT_GDBUS_METHOD_CALL_TMPL_VOID (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                   \
 
468
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_VOID));
 
469
 
 
470
#define E_INIT_GDBUS_METHOD_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                           \
 
471
        E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED (BOOLEAN, BOOLEAN, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)\
 
472
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_BOOLEAN));
 
473
 
 
474
#define E_INIT_GDBUS_METHOD_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                            \
 
475
        E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED (STRING, STRING, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)  \
 
476
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_STRING));
 
477
 
 
478
#define E_INIT_GDBUS_METHOD_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                              \
 
479
        E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED (BOXED, STRV, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)     \
 
480
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_STRV));
 
481
 
 
482
#define E_INIT_GDBUS_METHOD_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                              \
 
483
        E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED (UINT, UINT, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)      \
 
484
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_UINT));
 
485
 
 
486
#define E_INIT_GDBUS_METHOD_CALL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                         \
 
487
        E_INIT_GDBUS_METHOD_CALL_TMPL_VOID (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                   \
 
488
        g_hash_table_insert (_method_name_to_type, (gpointer) _dbus_sig_name_str, GUINT_TO_POINTER (E_GDBUS_TYPE_VOID | E_GDBUS_TYPE_IS_ASYNC));
 
489
 
 
490
#define E_INIT_GDBUS_METHOD_CALL_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                      \
 
491
        E_INIT_GDBUS_METHOD_CALL_ASYNC_TMPL_TYPED (BOOLEAN, BOOLEAN, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)
 
492
 
 
493
#define E_INIT_GDBUS_METHOD_CALL_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                       \
 
494
        E_INIT_GDBUS_METHOD_CALL_ASYNC_TMPL_TYPED (STRING, STRING, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)
 
495
 
 
496
#define E_INIT_GDBUS_METHOD_CALL_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                         \
 
497
        E_INIT_GDBUS_METHOD_CALL_ASYNC_TMPL_TYPED (BOXED, STRV, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)
 
498
 
 
499
#define E_INIT_GDBUS_METHOD_CALL_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                         \
 
500
        E_INIT_GDBUS_METHOD_CALL_ASYNC_TMPL_TYPED (UINT, UINT, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)
 
501
 
 
502
#define E_INIT_GDBUS_METHOD_ASYNC_VOID__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)    \
 
503
        E_INIT_GDBUS_METHOD_CALL_VOID (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
504
        E_INIT_GDBUS_METHOD_DONE_VOID (_iface_struct, _sig_name_var, _done_sig_id)
 
505
 
 
506
#define E_INIT_GDBUS_METHOD_ASYNC_VOID__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)  \
 
507
        E_INIT_GDBUS_METHOD_CALL_VOID   (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                      \
 
508
        E_INIT_GDBUS_METHOD_DONE_STRING (_iface_struct, _sig_name_var, _done_sig_id)
 
509
 
 
510
#define E_INIT_GDBUS_METHOD_ASYNC_VOID__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)    \
 
511
        E_INIT_GDBUS_METHOD_CALL_VOID (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
512
        E_INIT_GDBUS_METHOD_DONE_STRV (_iface_struct, _sig_name_var, _done_sig_id)
 
513
 
 
514
#define E_INIT_GDBUS_METHOD_ASYNC_BOOLEAN__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id) \
 
515
        E_INIT_GDBUS_METHOD_CALL_BOOLEAN (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                     \
 
516
        E_INIT_GDBUS_METHOD_DONE_VOID    (_iface_struct, _sig_name_var, _done_sig_id)
 
517
 
 
518
#define E_INIT_GDBUS_METHOD_ASYNC_UINT__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)    \
 
519
        E_INIT_GDBUS_METHOD_CALL_UINT (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
520
        E_INIT_GDBUS_METHOD_DONE_VOID (_iface_struct, _sig_name_var, _done_sig_id)
 
521
 
 
522
#define E_INIT_GDBUS_METHOD_ASYNC_STRING__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)  \
 
523
        E_INIT_GDBUS_METHOD_CALL_STRING (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                      \
 
524
        E_INIT_GDBUS_METHOD_DONE_VOID   (_iface_struct, _sig_name_var, _done_sig_id)
 
525
 
 
526
#define E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)    \
 
527
        E_INIT_GDBUS_METHOD_CALL_STRV (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
528
        E_INIT_GDBUS_METHOD_DONE_VOID (_iface_struct, _sig_name_var, _done_sig_id)
 
529
 
 
530
#define E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)\
 
531
        E_INIT_GDBUS_METHOD_CALL_STRING (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                      \
 
532
        E_INIT_GDBUS_METHOD_DONE_STRING (_iface_struct, _sig_name_var, _done_sig_id)
 
533
 
 
534
#define E_INIT_GDBUS_METHOD_ASYNC_STRING__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)  \
 
535
        E_INIT_GDBUS_METHOD_CALL_STRING (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                      \
 
536
        E_INIT_GDBUS_METHOD_DONE_STRV   (_iface_struct, _sig_name_var, _done_sig_id)
 
537
 
 
538
#define E_INIT_GDBUS_METHOD_ASYNC_STRV__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)  \
 
539
        E_INIT_GDBUS_METHOD_CALL_STRV (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
540
        E_INIT_GDBUS_METHOD_DONE_STRING (_iface_struct, _sig_name_var, _done_sig_id)
 
541
 
 
542
#define E_INIT_GDBUS_METHOD_ASYNC_STRV__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)    \
 
543
        E_INIT_GDBUS_METHOD_CALL_STRV (_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)                        \
 
544
        E_INIT_GDBUS_METHOD_DONE_STRV (_iface_struct, _sig_name_var, _done_sig_id)
 
545
 
 
546
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_VOID(_iface_name, _sig_name)                                                                               \
 
547
        static gboolean                                                                                                                                 \
 
548
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
549
        {                                                                                                                                               \
 
550
                return e_gdbus_signal_emission_hook_void (ihint, n_param_values, param_values, user_data, _iface_name);                                 \
 
551
        }
 
552
 
 
553
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_BOOLEAN(_iface_name, _sig_name)                                                                            \
 
554
        static gboolean                                                                                                                                 \
 
555
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
556
        {                                                                                                                                               \
 
557
                return e_gdbus_signal_emission_hook_boolean (ihint, n_param_values, param_values, user_data, _iface_name);                              \
 
558
        }
 
559
 
 
560
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRING(_iface_name, _sig_name)                                                                             \
 
561
        static gboolean                                                                                                                                 \
 
562
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
563
        {                                                                                                                                               \
 
564
                return e_gdbus_signal_emission_hook_string (ihint, n_param_values, param_values, user_data, _iface_name);                               \
 
565
        }
 
566
 
 
567
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV(_iface_name, _sig_name)                                                                               \
 
568
        static gboolean                                                                                                                                 \
 
569
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
570
        {                                                                                                                                               \
 
571
                return e_gdbus_signal_emission_hook_strv (ihint, n_param_values, param_values, user_data, _iface_name);                                 \
 
572
        }
 
573
 
 
574
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT(_iface_name, _sig_name)                                                                               \
 
575
        static gboolean                                                                                                                                 \
 
576
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
577
        {                                                                                                                                               \
 
578
                return e_gdbus_signal_emission_hook_uint (ihint, n_param_values, param_values, user_data, _iface_name);                                 \
 
579
        }
 
580
 
 
581
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT_STRING(_iface_name, _sig_name)                                                                                \
 
582
        static gboolean                                                                                                                                 \
 
583
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
584
        {                                                                                                                                               \
 
585
                return e_gdbus_signal_emission_hook_uint_string (ihint, n_param_values, param_values, user_data, _iface_name);                                  \
 
586
        }
 
587
 
 
588
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_VOID(_iface_name, _sig_name)                                                                         \
 
589
        static gboolean                                                                                                                                 \
 
590
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
591
        {                                                                                                                                               \
 
592
                return e_gdbus_signal_emission_hook_async_void (ihint, n_param_values, param_values, user_data, _iface_name);                           \
 
593
        }
 
594
 
 
595
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_BOOLEAN(_iface_name, _sig_name)                                                                      \
 
596
        static gboolean                                                                                                                                 \
 
597
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
598
        {                                                                                                                                               \
 
599
                return e_gdbus_signal_emission_hook_async_boolean (ihint, n_param_values, param_values, user_data, _iface_name);                        \
 
600
        }
 
601
 
 
602
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRING(_iface_name, _sig_name)                                                                       \
 
603
        static gboolean                                                                                                                                 \
 
604
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
605
        {                                                                                                                                               \
 
606
                return e_gdbus_signal_emission_hook_async_string (ihint, n_param_values, param_values, user_data, _iface_name);                         \
 
607
        }
 
608
 
 
609
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRV(_iface_name, _sig_name)                                                                         \
 
610
        static gboolean                                                                                                                                 \
 
611
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
612
        {                                                                                                                                               \
 
613
                return e_gdbus_signal_emission_hook_async_strv (ihint, n_param_values, param_values, user_data, _iface_name);                           \
 
614
        }
 
615
 
 
616
#define E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_UINT(_iface_name, _sig_name)                                                                         \
 
617
        static gboolean                                                                                                                                 \
 
618
        signal_emission_hook_cb_ ## _sig_name (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, gpointer user_data)      \
 
619
        {                                                                                                                                               \
 
620
                return e_gdbus_signal_emission_hook_async_uint (ihint, n_param_values, param_values, user_data, _iface_name);                           \
 
621
        }
 
622
 
 
623
#define E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID(_iface_name, _sig_name)                                                                    \
 
624
        E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_VOID (_iface_name, _sig_name ## _done)
 
625
 
 
626
#define E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_BOOLEAN(_iface_name, _sig_name)                                                                 \
 
627
        E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_BOOLEAN (_iface_name, _sig_name ## _done)
 
628
 
 
629
#define E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING(_iface_name, _sig_name)                                                                  \
 
630
        E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRING (_iface_name, _sig_name ## _done)
 
631
 
 
632
#define E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV(_iface_name, _sig_name)                                                                    \
 
633
        E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRV (_iface_name, _sig_name ## _done)
 
634
 
 
635
#define E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_UINT(_iface_name, _sig_name)                                                                    \
 
636
        E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_UINT (_iface_name, _sig_name ## _done)
 
637
 
 
638
#define E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID(_sig_name)                                                                                              \
 
639
        g_signal_connect (proxy, # _sig_name "_done", G_CALLBACK (e_gdbus_proxy_async_method_done_void), NULL);
 
640
 
 
641
#define E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_BOOLEAN(_sig_name)                                                                                           \
 
642
        g_signal_connect (proxy, # _sig_name "_done", G_CALLBACK (e_gdbus_proxy_async_method_done_boolean), NULL);
 
643
 
 
644
#define E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING(_sig_name)                                                                                            \
 
645
        g_signal_connect (proxy, # _sig_name "_done", G_CALLBACK (e_gdbus_proxy_async_method_done_string), NULL);
 
646
 
 
647
#define E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV(_sig_name)                                                                                              \
 
648
        g_signal_connect (proxy, # _sig_name "_done", G_CALLBACK (e_gdbus_proxy_async_method_done_strv), NULL);
 
649
 
 
650
#define E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_UINT(_sig_name)                                                                                              \
 
651
        g_signal_connect (proxy, # _sig_name "_done", G_CALLBACK (e_gdbus_proxy_async_method_done_uint), NULL);
 
652
 
 
653
void e_gdbus_proxy_emit_signal (GDBusProxy *proxy, GVariant *parameters, guint signal_id, guint signal_type);
 
654
void e_gdbus_stub_handle_method_call (GObject *stub_object, GDBusMethodInvocation *invocation, GVariant *parameters, const gchar *method_name, guint method_id, guint method_type);
 
655
 
 
656
gboolean e_gdbus_signal_emission_hook_void          (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
657
gboolean e_gdbus_signal_emission_hook_boolean       (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
658
gboolean e_gdbus_signal_emission_hook_string        (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
659
gboolean e_gdbus_signal_emission_hook_strv          (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
660
gboolean e_gdbus_signal_emission_hook_uint          (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
661
gboolean e_gdbus_signal_emission_hook_uint_string   (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
662
 
 
663
gboolean e_gdbus_signal_emission_hook_async_void    (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
664
gboolean e_gdbus_signal_emission_hook_async_boolean (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
665
gboolean e_gdbus_signal_emission_hook_async_string  (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
666
gboolean e_gdbus_signal_emission_hook_async_strv    (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
667
gboolean e_gdbus_signal_emission_hook_async_uint    (GSignalInvocationHint *ihint, guint n_param_values, const GValue *param_values, const gchar *signal_name, const gchar *iface_name);
 
668
 
 
669
/* GDBus calls method completion functions; after the 'async' method is expected associated done signal */
 
670
void e_gdbus_complete_async_method (gpointer object, GDBusMethodInvocation *invocation, guint opid);
 
671
void e_gdbus_complete_sync_method_void          (gpointer object, GDBusMethodInvocation *invocation, const GError *error);
 
672
void e_gdbus_complete_sync_method_boolean       (gpointer object, GDBusMethodInvocation *invocation, gboolean out_boolean, const GError *error);
 
673
void e_gdbus_complete_sync_method_string        (gpointer object, GDBusMethodInvocation *invocation, const gchar *out_string, const GError *error);
 
674
void e_gdbus_complete_sync_method_strv          (gpointer object, GDBusMethodInvocation *invocation, const gchar * const *out_strv, const GError *error);
 
675
void e_gdbus_complete_sync_method_uint          (gpointer object, GDBusMethodInvocation *invocation, guint out_uint, const GError *error);
 
676
 
 
677
/* callbacks on done signal handlers in the client proxy, which implements EGdbusAsyncOpKeeper interface;
 
678
   functions take ownership of out parameters and are responsible for their freeing */
 
679
void e_gdbus_proxy_async_method_done_void       (EGdbusAsyncOpKeeper *proxy, guint arg_opid, const GError *error);
 
680
void e_gdbus_proxy_async_method_done_boolean    (EGdbusAsyncOpKeeper *proxy, guint arg_opid, const GError *error, gboolean out_boolean);
 
681
void e_gdbus_proxy_async_method_done_string     (EGdbusAsyncOpKeeper *proxy, guint arg_opid, const GError *error, const gchar *out_string);
 
682
void e_gdbus_proxy_async_method_done_strv       (EGdbusAsyncOpKeeper *proxy, guint arg_opid, const GError *error, const gchar * const *out_strv);
 
683
void e_gdbus_proxy_async_method_done_uint       (EGdbusAsyncOpKeeper *proxy, guint arg_opid, const GError *error, guint out_uint);
 
684
 
 
685
void e_gdbus_proxy_call_void    (const gchar *method_name, gpointer source_tag, EGdbusAsyncOpKeeper *proxy, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
686
void e_gdbus_proxy_call_boolean (const gchar *method_name, gpointer source_tag, EGdbusAsyncOpKeeper *proxy, gboolean in_boolean, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
687
void e_gdbus_proxy_call_string  (const gchar *method_name, gpointer source_tag, EGdbusAsyncOpKeeper *proxy, const gchar *in_string, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
688
void e_gdbus_proxy_call_strv    (const gchar *method_name, gpointer source_tag, EGdbusAsyncOpKeeper *proxy, const gchar * const *in_strv, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
689
void e_gdbus_proxy_call_uint    (const gchar *method_name, gpointer source_tag, EGdbusAsyncOpKeeper *proxy, guint in_uint, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
690
 
 
691
gboolean e_gdbus_proxy_finish_call_void    (EGdbusAsyncOpKeeper *proxy, GAsyncResult *result, GError **error, gpointer source_tag);
 
692
gboolean e_gdbus_proxy_finish_call_boolean (EGdbusAsyncOpKeeper *proxy, GAsyncResult *result, gboolean *out_boolean, GError **error, gpointer source_tag);
 
693
gboolean e_gdbus_proxy_finish_call_string  (EGdbusAsyncOpKeeper *proxy, GAsyncResult *result, gchar **out_string, GError **error, gpointer source_tag);
 
694
gboolean e_gdbus_proxy_finish_call_strv    (EGdbusAsyncOpKeeper *proxy, GAsyncResult *result, gchar ***out_strv, GError **error, gpointer source_tag);
 
695
gboolean e_gdbus_proxy_finish_call_uint    (EGdbusAsyncOpKeeper *proxy, GAsyncResult *result, guint *out_uint, GError **error, gpointer source_tag);
 
696
 
 
697
typedef void (* EGdbusCallStartVoid)    (GDBusProxy *proxy, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
698
typedef void (* EGdbusCallStartBoolean) (GDBusProxy *proxy, gboolean in_boolean, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
699
typedef void (* EGdbusCallStartString)  (GDBusProxy *proxy, const gchar *in_string, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
700
typedef void (* EGdbusCallStartStrv)    (GDBusProxy *proxy, const gchar * const *in_strv, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
701
typedef void (* EGdbusCallStartUint)    (GDBusProxy *proxy, guint in_uint, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
702
 
 
703
typedef gboolean (* EGdbusCallFinishVoid)       (GDBusProxy *proxy, GAsyncResult *result, GError **error);
 
704
typedef gboolean (* EGdbusCallFinishBoolean)    (GDBusProxy *proxy, GAsyncResult *result, gboolean *out_boolean, GError **error);
 
705
typedef gboolean (* EGdbusCallFinishString)     (GDBusProxy *proxy, GAsyncResult *result, gchar **out_string, GError **error);
 
706
typedef gboolean (* EGdbusCallFinishStrv)       (GDBusProxy *proxy, GAsyncResult *result, gchar ***out_strv, GError **error);
 
707
typedef gboolean (* EGdbusCallFinishUint)       (GDBusProxy *proxy, GAsyncResult *result, guint *out_uint, GError **error);
 
708
 
 
709
/* this is for methods which are dividied into invocation and done signal */
 
710
gboolean e_gdbus_proxy_call_sync_void__void     (GDBusProxy *proxy, GCancellable *cancellable, GError **error, EGdbusCallStartVoid start_func, EGdbusCallFinishVoid finish_func);
 
711
gboolean e_gdbus_proxy_call_sync_void__boolean  (GDBusProxy *proxy, gboolean *out_boolean, GCancellable *cancellable, GError **error, EGdbusCallStartVoid start_func, EGdbusCallFinishBoolean finish_func);
 
712
gboolean e_gdbus_proxy_call_sync_void__string   (GDBusProxy *proxy, gchar **out_string, GCancellable *cancellable, GError **error, EGdbusCallStartVoid start_func, EGdbusCallFinishString finish_func);
 
713
gboolean e_gdbus_proxy_call_sync_void__strv     (GDBusProxy *proxy, gchar ***out_strv, GCancellable *cancellable, GError **error, EGdbusCallStartVoid start_func, EGdbusCallFinishStrv finish_func);
 
714
gboolean e_gdbus_proxy_call_sync_void__uint     (GDBusProxy *proxy, guint *out_uint, GCancellable *cancellable, GError **error, EGdbusCallStartVoid start_func, EGdbusCallFinishUint finish_func);
 
715
gboolean e_gdbus_proxy_call_sync_boolean__void  (GDBusProxy *proxy, gboolean in_boolean, GCancellable *cancellable, GError **error, EGdbusCallStartBoolean start_func, EGdbusCallFinishVoid finish_func);
 
716
gboolean e_gdbus_proxy_call_sync_string__void   (GDBusProxy *proxy, const gchar *in_string, GCancellable *cancellable, GError **error, EGdbusCallStartString start_func, EGdbusCallFinishVoid finish_func);
 
717
gboolean e_gdbus_proxy_call_sync_strv__void     (GDBusProxy *proxy, const gchar * const *in_strv, GCancellable *cancellable, GError **error, EGdbusCallStartStrv start_func, EGdbusCallFinishVoid finish_func);
 
718
gboolean e_gdbus_proxy_call_sync_uint__void     (GDBusProxy *proxy, guint in_uint, GCancellable *cancellable, GError **error, EGdbusCallStartUint start_func, EGdbusCallFinishVoid finish_func);
 
719
gboolean e_gdbus_proxy_call_sync_string__string (GDBusProxy *proxy, const gchar *in_string, gchar **out_string, GCancellable *cancellable, GError **error, EGdbusCallStartString start_func, EGdbusCallFinishString finish_func);
 
720
gboolean e_gdbus_proxy_call_sync_string__strv   (GDBusProxy *proxy, const gchar *in_string, gchar ***out_strv, GCancellable *cancellable, GError **error, EGdbusCallStartString start_func, EGdbusCallFinishStrv finish_func);
 
721
gboolean e_gdbus_proxy_call_sync_strv__string   (GDBusProxy *proxy, const gchar * const *in_strv, gchar **out_string, GCancellable *cancellable, GError **error, EGdbusCallStartStrv start_func, EGdbusCallFinishString finish_func);
 
722
gboolean e_gdbus_proxy_call_sync_strv__strv     (GDBusProxy *proxy, const gchar * const *in_strv, gchar ***out_strv, GCancellable *cancellable, GError **error, EGdbusCallStartStrv start_func, EGdbusCallFinishStrv finish_func);
 
723
 
 
724
/* this is for "synchronous" methods, those without done signal */
 
725
void     e_gdbus_proxy_method_call_void                 (const gchar *method_name, GDBusProxy *proxy, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
726
void     e_gdbus_proxy_method_call_boolean              (const gchar *method_name, GDBusProxy *proxy, gboolean in_boolean, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
727
void     e_gdbus_proxy_method_call_string               (const gchar *method_name, GDBusProxy *proxy, const gchar *in_string, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
728
void     e_gdbus_proxy_method_call_strv                 (const gchar *method_name, GDBusProxy *proxy, const gchar * const *in_strv, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
729
void     e_gdbus_proxy_method_call_uint                 (const gchar *method_name, GDBusProxy *proxy, guint in_uint, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data);
 
730
 
 
731
gboolean e_gdbus_proxy_method_call_finish_void          (GDBusProxy *proxy, GAsyncResult *result, GError **error);
 
732
gboolean e_gdbus_proxy_method_call_finish_boolean       (GDBusProxy *proxy, GAsyncResult *result, gboolean *out_boolean, GError **error);
 
733
gboolean e_gdbus_proxy_method_call_finish_string        (GDBusProxy *proxy, GAsyncResult *result, gchar **out_string, GError **error);
 
734
gboolean e_gdbus_proxy_method_call_finish_strv          (GDBusProxy *proxy, GAsyncResult *result, gchar ***out_strv, GError **error);
 
735
gboolean e_gdbus_proxy_method_call_finish_uint          (GDBusProxy *proxy, GAsyncResult *result, guint *out_uint, GError **error);
 
736
 
 
737
gboolean e_gdbus_proxy_method_call_sync_void__void      (const gchar *method_name, GDBusProxy *proxy, GCancellable *cancellable, GError **error);
 
738
gboolean e_gdbus_proxy_method_call_sync_boolean__void   (const gchar *method_name, GDBusProxy *proxy, gboolean in_boolean, GCancellable *cancellable, GError **error);
 
739
gboolean e_gdbus_proxy_method_call_sync_string__void    (const gchar *method_name, GDBusProxy *proxy, const gchar *in_string, GCancellable *cancellable, GError **error);
 
740
gboolean e_gdbus_proxy_method_call_sync_strv__void      (const gchar *method_name, GDBusProxy *proxy, const gchar * const *in_strv, GCancellable *cancellable, GError **error);
 
741
gboolean e_gdbus_proxy_method_call_sync_uint__void      (const gchar *method_name, GDBusProxy *proxy, guint in_uint, GCancellable *cancellable, GError **error);
 
742
gboolean e_gdbus_proxy_method_call_sync_string__string  (const gchar *method_name, GDBusProxy *proxy, const gchar *in_string, gchar **out_string, GCancellable *cancellable, GError **error);
 
743
gboolean e_gdbus_proxy_method_call_sync_strv__string    (const gchar *method_name, GDBusProxy *proxy, const gchar * const *in_strv, gchar **out_string, GCancellable *cancellable, GError **error);
 
744
 
 
745
gchar ** e_gdbus_templates_encode_error (const GError *in_error);
 
746
gboolean e_gdbus_templates_decode_error (const gchar * const *in_strv, GError **out_error);
 
747
 
 
748
G_END_DECLS
 
749
 
 
750
#endif /* E_GDBUS_TEMPLATES_H */