← Back to branch summary

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

« back to all changes in this revision

Viewing changes to calendar/libegdbus/e-gdbus-egdbuscal.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:
calendar/libegdbus/e-gdbus-egdbuscal.h
1
 
/* File:       e-gdbus-egdbuscal.h
2
 
 *
3
 
 * GType name: EGdbusCal
4
 
 * D-Bus name: org.gnome.evolution.dataserver.Calendar
5
 
 *
6
 
 * Generated by GDBus Binding Tool 0.1. DO NOT EDIT.
7
 
 */
8
 
 
9
 
#ifndef __E_GDBUS_E_GDBUS_CAL_H__
10
 
#define __E_GDBUS_E_GDBUS_CAL_H__
11
 
 
12
 
#include <gio/gio.h>
13
 
 
14
 
#include "e-gdbus-typemappers.h"
15
 
G_BEGIN_DECLS
16
 
 
17
 
#define E_GDBUS_TYPE_CAL         (e_gdbus_cal_get_type ())
18
 
#define E_GDBUS_CAL(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), E_GDBUS_TYPE_CAL, EGdbusCal))
19
 
#define E_GDBUS_IS_CAL(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_GDBUS_TYPE_CAL))
20
 
#define E_GDBUS_CAL_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE((o), E_GDBUS_TYPE_CAL, EGdbusCalIface))
21
 
 
22
 
/**
23
 
 * EGdbusCal:
24
 
 *
25
 
 * Opaque type representing a proxy or an exported object.
26
 
 */
27
 
typedef struct _EGdbusCal EGdbusCal; /* Dummy typedef */
28
 
/**
29
 
 * EGdbusCalIface:
30
 
 * @parent_iface: The parent interface.
31
 
 * @auth_required: Handler for the #EGdbusCal::auth-required signal.
32
 
 * @backend_error: Handler for the #EGdbusCal::backend-error signal.
33
 
 * @readonly: Handler for the #EGdbusCal::readonly signal.
34
 
 * @mode: Handler for the #EGdbusCal::mode signal.
35
 
 * @handle_get_uri: Handler for the #EGdbusCal::handle-get-uri signal.
36
 
 * @handle_get_cache_dir: Handler for the #EGdbusCal::handle-get-cache-dir signal.
37
 
 * @handle_open: Handler for the #EGdbusCal::handle-open signal.
38
 
 * @handle_refresh: Handler for the #EGdbusCal::handle-refresh signal.
39
 
 * @handle_close: Handler for the #EGdbusCal::handle-close signal.
40
 
 * @handle_remove: Handler for the #EGdbusCal::handle-remove signal.
41
 
 * @handle_is_read_only: Handler for the #EGdbusCal::handle-is-read-only signal.
42
 
 * @handle_get_cal_address: Handler for the #EGdbusCal::handle-get-cal-address signal.
43
 
 * @handle_get_alarm_email_address: Handler for the #EGdbusCal::handle-get-alarm-email-address signal.
44
 
 * @handle_get_ldap_attribute: Handler for the #EGdbusCal::handle-get-ldap-attribute signal.
45
 
 * @handle_get_scheduling_information: Handler for the #EGdbusCal::handle-get-scheduling-information signal.
46
 
 * @handle_set_mode: Handler for the #EGdbusCal::handle-set-mode signal.
47
 
 * @handle_get_default_object: Handler for the #EGdbusCal::handle-get-default-object signal.
48
 
 * @handle_get_object: Handler for the #EGdbusCal::handle-get-object signal.
49
 
 * @handle_get_object_list: Handler for the #EGdbusCal::handle-get-object-list signal.
50
 
 * @handle_get_changes: Handler for the #EGdbusCal::handle-get-changes signal.
51
 
 * @handle_get_free_busy: Handler for the #EGdbusCal::handle-get-free-busy signal.
52
 
 * @handle_discard_alarm: Handler for the #EGdbusCal::handle-discard-alarm signal.
53
 
 * @handle_create_object: Handler for the #EGdbusCal::handle-create-object signal.
54
 
 * @handle_modify_object: Handler for the #EGdbusCal::handle-modify-object signal.
55
 
 * @handle_remove_object: Handler for the #EGdbusCal::handle-remove-object signal.
56
 
 * @handle_receive_objects: Handler for the #EGdbusCal::handle-receive-objects signal.
57
 
 * @handle_send_objects: Handler for the #EGdbusCal::handle-send-objects signal.
58
 
 * @handle_get_attachment_list: Handler for the #EGdbusCal::handle-get-attachment-list signal.
59
 
 * @handle_get_query: Handler for the #EGdbusCal::handle-get-query signal.
60
 
 * @handle_get_timezone: Handler for the #EGdbusCal::handle-get-timezone signal.
61
 
 * @handle_add_timezone: Handler for the #EGdbusCal::handle-add-timezone signal.
62
 
 * @handle_set_default_timezone: Handler for the #EGdbusCal::handle-set-default-timezone signal.
63
 
 *
64
 
 * Virtual table.
65
 
 */
66
 
typedef struct _EGdbusCalIface EGdbusCalIface;
67
 
 
68
 
GType e_gdbus_cal_get_type (void) G_GNUC_CONST;
69
 
 
70
 
/* ---------------------------------------------------------------------- */
71
 
 
72
 
typedef struct _EGdbusCalProxy EGdbusCalProxy;
73
 
typedef struct _EGdbusCalProxyClass EGdbusCalProxyClass;
74
 
 
75
 
/**
76
 
 * EGdbusCalProxyPrivate:
77
 
 *
78
 
 * The #EGdbusCalProxyPrivate structure contains only private data.
79
 
 */
80
 
typedef struct _EGdbusCalProxyPrivate EGdbusCalProxyPrivate;
81
 
 
82
 
/**
83
 
 * EGdbusCalProxy:
84
 
 *
85
 
 * The #EGdbusCalProxy structure contains only private data and
86
 
 * should only be accessed using the provided API.
87
 
 */
88
 
struct _EGdbusCalProxy
89
 
{
90
 
  GDBusProxy parent_instance;
91
 
  EGdbusCalProxyPrivate *priv;
92
 
};
93
 
 
94
 
/**
95
 
 * EGdbusCalProxyClass:
96
 
 *
97
 
 * Class structure for #EGdbusCalProxy.
98
 
 */
99
 
struct _EGdbusCalProxyClass
100
 
{
101
 
  GDBusProxyClass parent_class;
102
 
};
103
 
 
104
 
#define E_GDBUS_TYPE_CAL_PROXY (e_gdbus_cal_proxy_get_type ())
105
 
GType e_gdbus_cal_proxy_get_type (void) G_GNUC_CONST;
106
 
 
107
 
void e_gdbus_cal_proxy_new (GDBusConnection     *connection,
108
 
                   GDBusProxyFlags      flags,
109
 
                   const gchar         *name,
110
 
                   const gchar         *object_path,
111
 
                   GCancellable        *cancellable,
112
 
                   GAsyncReadyCallback  callback,
113
 
                   gpointer             user_data);
114
 
EGdbusCal *e_gdbus_cal_proxy_new_finish (GAsyncResult  *res,
115
 
                        GError       **error);
116
 
EGdbusCal *e_gdbus_cal_proxy_new_sync (GDBusConnection     *connection,
117
 
                       GDBusProxyFlags      flags,
118
 
                       const gchar         *name,
119
 
                       const gchar         *object_path,
120
 
                       GCancellable        *cancellable,
121
 
                       GError             **error);
122
 
 
123
 
void e_gdbus_cal_proxy_new_for_bus (GBusType             bus_type,
124
 
                           GDBusProxyFlags      flags,
125
 
                           const gchar         *name,
126
 
                           const gchar         *object_path,
127
 
                           GCancellable        *cancellable,
128
 
                           GAsyncReadyCallback  callback,
129
 
                           gpointer             user_data);
130
 
EGdbusCal *e_gdbus_cal_proxy_new_for_bus_finish (GAsyncResult  *res,
131
 
                                 GError       **error);
132
 
EGdbusCal *e_gdbus_cal_proxy_new_for_bus_sync (GBusType             bus_type,
133
 
                               GDBusProxyFlags      flags,
134
 
                               const gchar         *name,
135
 
                               const gchar         *object_path,
136
 
                               GCancellable        *cancellable,
137
 
                               GError             **error);
138
 
 
139
 
/* ---------------------------------------------------------------------- */
140
 
 
141
 
typedef struct _EGdbusCalStub EGdbusCalStub;
142
 
typedef struct _EGdbusCalStubClass EGdbusCalStubClass;
143
 
 
144
 
/**
145
 
 * EGdbusCalStubPrivate:
146
 
 *
147
 
 * The #EGdbusCalStubPrivate structure contains only private data.
148
 
 */
149
 
typedef struct _EGdbusCalStubPrivate EGdbusCalStubPrivate;
150
 
 
151
 
/**
152
 
 * EGdbusCalStub:
153
 
 *
154
 
 * The #EGdbusCalStub structure contains only private data and
155
 
 * should only be accessed using the provided API.
156
 
 */
157
 
struct _EGdbusCalStub
158
 
{
159
 
  GObject parent_instance;
160
 
  EGdbusCalStubPrivate *priv;
161
 
};
162
 
 
163
 
/**
164
 
 * EGdbusCalStubClass:
165
 
 *
166
 
 * Class structure for #EGdbusCalStub.
167
 
 */
168
 
struct _EGdbusCalStubClass
169
 
{
170
 
  GObjectClass parent_class;
171
 
};
172
 
 
173
 
#define E_GDBUS_TYPE_CAL_STUB (e_gdbus_cal_stub_get_type ())
174
 
GType e_gdbus_cal_stub_get_type (void) G_GNUC_CONST;
175
 
 
176
 
EGdbusCal *e_gdbus_cal_stub_new (void);
177
 
 
178
 
guint e_gdbus_cal_register_object (EGdbusCal *object,
179
 
                    GDBusConnection *connection,
180
 
                    const gchar *object_path,
181
 
                    GError **error);
182
 
 
183
 
void e_gdbus_cal_drain_notify (EGdbusCal *object);
184
 
 
185
 
const GDBusInterfaceInfo *e_gdbus_cal_interface_info (void) G_GNUC_CONST;
186
 
 
187
 
struct _EGdbusCalIface
188
 
{
189
 
  GTypeInterface parent_iface;
190
 
 
191
 
  /* Signal handlers for receiving D-Bus signals: */
192
 
  void (*auth_required) (
193
 
        EGdbusCal *object);
194
 
  void (*backend_error) (
195
 
        EGdbusCal *object,
196
 
        const gchar *arg_error);
197
 
  void (*readonly) (
198
 
        EGdbusCal *object,
199
 
        gboolean arg_is_readonly);
200
 
  void (*mode) (
201
 
        EGdbusCal *object,
202
 
        gint arg_mode);
203
 
 
204
 
  /* Signal handlers for handling D-Bus method calls: */
205
 
  gboolean (*handle_get_uri) (
206
 
        EGdbusCal *object,
207
 
        GDBusMethodInvocation *invocation);
208
 
  gboolean (*handle_get_cache_dir) (
209
 
        EGdbusCal *object,
210
 
        GDBusMethodInvocation *invocation);
211
 
  gboolean (*handle_open) (
212
 
        EGdbusCal *object,
213
 
        GDBusMethodInvocation *invocation,
214
 
        gboolean in_only_if_exists,
215
 
        const gchar *in_username,
216
 
        const gchar *in_password);
217
 
  gboolean (*handle_refresh) (
218
 
        EGdbusCal *object,
219
 
        GDBusMethodInvocation *invocation);
220
 
  gboolean (*handle_close) (
221
 
        EGdbusCal *object,
222
 
        GDBusMethodInvocation *invocation);
223
 
  gboolean (*handle_remove) (
224
 
        EGdbusCal *object,
225
 
        GDBusMethodInvocation *invocation);
226
 
  gboolean (*handle_is_read_only) (
227
 
        EGdbusCal *object,
228
 
        GDBusMethodInvocation *invocation);
229
 
  gboolean (*handle_get_cal_address) (
230
 
        EGdbusCal *object,
231
 
        GDBusMethodInvocation *invocation);
232
 
  gboolean (*handle_get_alarm_email_address) (
233
 
        EGdbusCal *object,
234
 
        GDBusMethodInvocation *invocation);
235
 
  gboolean (*handle_get_ldap_attribute) (
236
 
        EGdbusCal *object,
237
 
        GDBusMethodInvocation *invocation);
238
 
  gboolean (*handle_get_scheduling_information) (
239
 
        EGdbusCal *object,
240
 
        GDBusMethodInvocation *invocation);
241
 
  gboolean (*handle_set_mode) (
242
 
        EGdbusCal *object,
243
 
        GDBusMethodInvocation *invocation,
244
 
        guint in_mode);
245
 
  gboolean (*handle_get_default_object) (
246
 
        EGdbusCal *object,
247
 
        GDBusMethodInvocation *invocation);
248
 
  gboolean (*handle_get_object) (
249
 
        EGdbusCal *object,
250
 
        GDBusMethodInvocation *invocation,
251
 
        const gchar *in_uid,
252
 
        const gchar *in_rid);
253
 
  gboolean (*handle_get_object_list) (
254
 
        EGdbusCal *object,
255
 
        GDBusMethodInvocation *invocation,
256
 
        const gchar *in_sexp);
257
 
  gboolean (*handle_get_changes) (
258
 
        EGdbusCal *object,
259
 
        GDBusMethodInvocation *invocation,
260
 
        const gchar *in_change_id);
261
 
  gboolean (*handle_get_free_busy) (
262
 
        EGdbusCal *object,
263
 
        GDBusMethodInvocation *invocation,
264
 
        const gchar * const *in_user_list,
265
 
        guint in_start,
266
 
        guint in_end);
267
 
  gboolean (*handle_discard_alarm) (
268
 
        EGdbusCal *object,
269
 
        GDBusMethodInvocation *invocation,
270
 
        const gchar *in_uid,
271
 
        const gchar *in_auid);
272
 
  gboolean (*handle_create_object) (
273
 
        EGdbusCal *object,
274
 
        GDBusMethodInvocation *invocation,
275
 
        const gchar *in_calobj);
276
 
  gboolean (*handle_modify_object) (
277
 
        EGdbusCal *object,
278
 
        GDBusMethodInvocation *invocation,
279
 
        const gchar *in_calobj,
280
 
        guint in_mod);
281
 
  gboolean (*handle_remove_object) (
282
 
        EGdbusCal *object,
283
 
        GDBusMethodInvocation *invocation,
284
 
        const gchar *in_uid,
285
 
        const gchar *in_rid,
286
 
        guint in_mod);
287
 
  gboolean (*handle_receive_objects) (
288
 
        EGdbusCal *object,
289
 
        GDBusMethodInvocation *invocation,
290
 
        const gchar *in_calobj);
291
 
  gboolean (*handle_send_objects) (
292
 
        EGdbusCal *object,
293
 
        GDBusMethodInvocation *invocation,
294
 
        const gchar *in_calobj);
295
 
  gboolean (*handle_get_attachment_list) (
296
 
        EGdbusCal *object,
297
 
        GDBusMethodInvocation *invocation,
298
 
        const gchar *in_uid,
299
 
        const gchar *in_rid);
300
 
  gboolean (*handle_get_query) (
301
 
        EGdbusCal *object,
302
 
        GDBusMethodInvocation *invocation,
303
 
        const gchar *in_sexp);
304
 
  gboolean (*handle_get_timezone) (
305
 
        EGdbusCal *object,
306
 
        GDBusMethodInvocation *invocation,
307
 
        const gchar *in_tzid);
308
 
  gboolean (*handle_add_timezone) (
309
 
        EGdbusCal *object,
310
 
        GDBusMethodInvocation *invocation,
311
 
        const gchar *in_tz);
312
 
  gboolean (*handle_set_default_timezone) (
313
 
        EGdbusCal *object,
314
 
        GDBusMethodInvocation *invocation,
315
 
        const gchar *in_tz);
316
 
};
317
 
 
318
 
/* C Bindings for properties */
319
 
 
320
 
/* D-Bus Methods */
321
 
void e_gdbus_cal_call_get_uri (
322
 
        EGdbusCal *proxy,
323
 
        GCancellable *cancellable,
324
 
        GAsyncReadyCallback callback,
325
 
        gpointer user_data);
326
 
 
327
 
gboolean e_gdbus_cal_call_get_uri_finish (
328
 
        EGdbusCal *proxy,
329
 
        gchar **out_str_uri_copy,
330
 
        GAsyncResult *res,
331
 
        GError **error);
332
 
 
333
 
gboolean e_gdbus_cal_call_get_uri_sync (
334
 
        EGdbusCal *proxy,
335
 
        gchar **out_str_uri_copy,
336
 
        GCancellable *cancellable,
337
 
        GError **error);
338
 
 
339
 
void e_gdbus_cal_call_get_cache_dir (
340
 
        EGdbusCal *proxy,
341
 
        GCancellable *cancellable,
342
 
        GAsyncReadyCallback callback,
343
 
        gpointer user_data);
344
 
 
345
 
gboolean e_gdbus_cal_call_get_cache_dir_finish (
346
 
        EGdbusCal *proxy,
347
 
        gchar **out_dirname,
348
 
        GAsyncResult *res,
349
 
        GError **error);
350
 
 
351
 
gboolean e_gdbus_cal_call_get_cache_dir_sync (
352
 
        EGdbusCal *proxy,
353
 
        gchar **out_dirname,
354
 
        GCancellable *cancellable,
355
 
        GError **error);
356
 
 
357
 
void e_gdbus_cal_call_open (
358
 
        EGdbusCal *proxy,
359
 
        gboolean in_only_if_exists,
360
 
        const gchar *in_username,
361
 
        const gchar *in_password,
362
 
        GCancellable *cancellable,
363
 
        GAsyncReadyCallback callback,
364
 
        gpointer user_data);
365
 
 
366
 
gboolean e_gdbus_cal_call_open_finish (
367
 
        EGdbusCal *proxy,
368
 
        GAsyncResult *res,
369
 
        GError **error);
370
 
 
371
 
gboolean e_gdbus_cal_call_open_sync (
372
 
        EGdbusCal *proxy,
373
 
        gboolean in_only_if_exists,
374
 
        const gchar *in_username,
375
 
        const gchar *in_password,
376
 
        GCancellable *cancellable,
377
 
        GError **error);
378
 
 
379
 
void e_gdbus_cal_call_refresh (
380
 
        EGdbusCal *proxy,
381
 
        GCancellable *cancellable,
382
 
        GAsyncReadyCallback callback,
383
 
        gpointer user_data);
384
 
 
385
 
gboolean e_gdbus_cal_call_refresh_finish (
386
 
        EGdbusCal *proxy,
387
 
        GAsyncResult *res,
388
 
        GError **error);
389
 
 
390
 
gboolean e_gdbus_cal_call_refresh_sync (
391
 
        EGdbusCal *proxy,
392
 
        GCancellable *cancellable,
393
 
        GError **error);
394
 
 
395
 
void e_gdbus_cal_call_close (
396
 
        EGdbusCal *proxy,
397
 
        GCancellable *cancellable,
398
 
        GAsyncReadyCallback callback,
399
 
        gpointer user_data);
400
 
 
401
 
gboolean e_gdbus_cal_call_close_finish (
402
 
        EGdbusCal *proxy,
403
 
        GAsyncResult *res,
404
 
        GError **error);
405
 
 
406
 
gboolean e_gdbus_cal_call_close_sync (
407
 
        EGdbusCal *proxy,
408
 
        GCancellable *cancellable,
409
 
        GError **error);
410
 
 
411
 
void e_gdbus_cal_call_remove (
412
 
        EGdbusCal *proxy,
413
 
        GCancellable *cancellable,
414
 
        GAsyncReadyCallback callback,
415
 
        gpointer user_data);
416
 
 
417
 
gboolean e_gdbus_cal_call_remove_finish (
418
 
        EGdbusCal *proxy,
419
 
        GAsyncResult *res,
420
 
        GError **error);
421
 
 
422
 
gboolean e_gdbus_cal_call_remove_sync (
423
 
        EGdbusCal *proxy,
424
 
        GCancellable *cancellable,
425
 
        GError **error);
426
 
 
427
 
void e_gdbus_cal_call_is_read_only (
428
 
        EGdbusCal *proxy,
429
 
        GCancellable *cancellable,
430
 
        GAsyncReadyCallback callback,
431
 
        gpointer user_data);
432
 
 
433
 
gboolean e_gdbus_cal_call_is_read_only_finish (
434
 
        EGdbusCal *proxy,
435
 
        GAsyncResult *res,
436
 
        GError **error);
437
 
 
438
 
gboolean e_gdbus_cal_call_is_read_only_sync (
439
 
        EGdbusCal *proxy,
440
 
        GCancellable *cancellable,
441
 
        GError **error);
442
 
 
443
 
void e_gdbus_cal_call_get_cal_address (
444
 
        EGdbusCal *proxy,
445
 
        GCancellable *cancellable,
446
 
        GAsyncReadyCallback callback,
447
 
        gpointer user_data);
448
 
 
449
 
gboolean e_gdbus_cal_call_get_cal_address_finish (
450
 
        EGdbusCal *proxy,
451
 
        gchar **out_address,
452
 
        GAsyncResult *res,
453
 
        GError **error);
454
 
 
455
 
gboolean e_gdbus_cal_call_get_cal_address_sync (
456
 
        EGdbusCal *proxy,
457
 
        gchar **out_address,
458
 
        GCancellable *cancellable,
459
 
        GError **error);
460
 
 
461
 
void e_gdbus_cal_call_get_alarm_email_address (
462
 
        EGdbusCal *proxy,
463
 
        GCancellable *cancellable,
464
 
        GAsyncReadyCallback callback,
465
 
        gpointer user_data);
466
 
 
467
 
gboolean e_gdbus_cal_call_get_alarm_email_address_finish (
468
 
        EGdbusCal *proxy,
469
 
        gchar **out_address,
470
 
        GAsyncResult *res,
471
 
        GError **error);
472
 
 
473
 
gboolean e_gdbus_cal_call_get_alarm_email_address_sync (
474
 
        EGdbusCal *proxy,
475
 
        gchar **out_address,
476
 
        GCancellable *cancellable,
477
 
        GError **error);
478
 
 
479
 
void e_gdbus_cal_call_get_ldap_attribute (
480
 
        EGdbusCal *proxy,
481
 
        GCancellable *cancellable,
482
 
        GAsyncReadyCallback callback,
483
 
        gpointer user_data);
484
 
 
485
 
gboolean e_gdbus_cal_call_get_ldap_attribute_finish (
486
 
        EGdbusCal *proxy,
487
 
        gchar **out_address,
488
 
        GAsyncResult *res,
489
 
        GError **error);
490
 
 
491
 
gboolean e_gdbus_cal_call_get_ldap_attribute_sync (
492
 
        EGdbusCal *proxy,
493
 
        gchar **out_address,
494
 
        GCancellable *cancellable,
495
 
        GError **error);
496
 
 
497
 
void e_gdbus_cal_call_get_scheduling_information (
498
 
        EGdbusCal *proxy,
499
 
        GCancellable *cancellable,
500
 
        GAsyncReadyCallback callback,
501
 
        gpointer user_data);
502
 
 
503
 
gboolean e_gdbus_cal_call_get_scheduling_information_finish (
504
 
        EGdbusCal *proxy,
505
 
        gchar **out_capabilities,
506
 
        GAsyncResult *res,
507
 
        GError **error);
508
 
 
509
 
gboolean e_gdbus_cal_call_get_scheduling_information_sync (
510
 
        EGdbusCal *proxy,
511
 
        gchar **out_capabilities,
512
 
        GCancellable *cancellable,
513
 
        GError **error);
514
 
 
515
 
void e_gdbus_cal_call_set_mode (
516
 
        EGdbusCal *proxy,
517
 
        guint in_mode,
518
 
        GCancellable *cancellable,
519
 
        GAsyncReadyCallback callback,
520
 
        gpointer user_data);
521
 
 
522
 
gboolean e_gdbus_cal_call_set_mode_finish (
523
 
        EGdbusCal *proxy,
524
 
        GAsyncResult *res,
525
 
        GError **error);
526
 
 
527
 
gboolean e_gdbus_cal_call_set_mode_sync (
528
 
        EGdbusCal *proxy,
529
 
        guint in_mode,
530
 
        GCancellable *cancellable,
531
 
        GError **error);
532
 
 
533
 
void e_gdbus_cal_call_get_default_object (
534
 
        EGdbusCal *proxy,
535
 
        GCancellable *cancellable,
536
 
        GAsyncReadyCallback callback,
537
 
        gpointer user_data);
538
 
 
539
 
gboolean e_gdbus_cal_call_get_default_object_finish (
540
 
        EGdbusCal *proxy,
541
 
        gchar **out_object,
542
 
        GAsyncResult *res,
543
 
        GError **error);
544
 
 
545
 
gboolean e_gdbus_cal_call_get_default_object_sync (
546
 
        EGdbusCal *proxy,
547
 
        gchar **out_object,
548
 
        GCancellable *cancellable,
549
 
        GError **error);
550
 
 
551
 
void e_gdbus_cal_call_get_object (
552
 
        EGdbusCal *proxy,
553
 
        const gchar *in_uid,
554
 
        const gchar *in_rid,
555
 
        GCancellable *cancellable,
556
 
        GAsyncReadyCallback callback,
557
 
        gpointer user_data);
558
 
 
559
 
gboolean e_gdbus_cal_call_get_object_finish (
560
 
        EGdbusCal *proxy,
561
 
        gchar **out_object,
562
 
        GAsyncResult *res,
563
 
        GError **error);
564
 
 
565
 
gboolean e_gdbus_cal_call_get_object_sync (
566
 
        EGdbusCal *proxy,
567
 
        const gchar *in_uid,
568
 
        const gchar *in_rid,
569
 
        gchar **out_object,
570
 
        GCancellable *cancellable,
571
 
        GError **error);
572
 
 
573
 
void e_gdbus_cal_call_get_object_list (
574
 
        EGdbusCal *proxy,
575
 
        const gchar *in_sexp,
576
 
        GCancellable *cancellable,
577
 
        GAsyncReadyCallback callback,
578
 
        gpointer user_data);
579
 
 
580
 
gboolean e_gdbus_cal_call_get_object_list_finish (
581
 
        EGdbusCal *proxy,
582
 
        gchar ***out_objects,
583
 
        GAsyncResult *res,
584
 
        GError **error);
585
 
 
586
 
gboolean e_gdbus_cal_call_get_object_list_sync (
587
 
        EGdbusCal *proxy,
588
 
        const gchar *in_sexp,
589
 
        gchar ***out_objects,
590
 
        GCancellable *cancellable,
591
 
        GError **error);
592
 
 
593
 
void e_gdbus_cal_call_get_changes (
594
 
        EGdbusCal *proxy,
595
 
        const gchar *in_change_id,
596
 
        GCancellable *cancellable,
597
 
        GAsyncReadyCallback callback,
598
 
        gpointer user_data);
599
 
 
600
 
gboolean e_gdbus_cal_call_get_changes_finish (
601
 
        EGdbusCal *proxy,
602
 
        gchar ***out_additions,
603
 
        gchar ***out_modifications,
604
 
        gchar ***out_removals,
605
 
        GAsyncResult *res,
606
 
        GError **error);
607
 
 
608
 
gboolean e_gdbus_cal_call_get_changes_sync (
609
 
        EGdbusCal *proxy,
610
 
        const gchar *in_change_id,
611
 
        gchar ***out_additions,
612
 
        gchar ***out_modifications,
613
 
        gchar ***out_removals,
614
 
        GCancellable *cancellable,
615
 
        GError **error);
616
 
 
617
 
void e_gdbus_cal_call_get_free_busy (
618
 
        EGdbusCal *proxy,
619
 
        const gchar * const *in_user_list,
620
 
        guint in_start,
621
 
        guint in_end,
622
 
        GCancellable *cancellable,
623
 
        GAsyncReadyCallback callback,
624
 
        gpointer user_data);
625
 
 
626
 
gboolean e_gdbus_cal_call_get_free_busy_finish (
627
 
        EGdbusCal *proxy,
628
 
        gchar ***out_freebusy,
629
 
        GAsyncResult *res,
630
 
        GError **error);
631
 
 
632
 
gboolean e_gdbus_cal_call_get_free_busy_sync (
633
 
        EGdbusCal *proxy,
634
 
        const gchar * const *in_user_list,
635
 
        guint in_start,
636
 
        guint in_end,
637
 
        gchar ***out_freebusy,
638
 
        GCancellable *cancellable,
639
 
        GError **error);
640
 
 
641
 
void e_gdbus_cal_call_discard_alarm (
642
 
        EGdbusCal *proxy,
643
 
        const gchar *in_uid,
644
 
        const gchar *in_auid,
645
 
        GCancellable *cancellable,
646
 
        GAsyncReadyCallback callback,
647
 
        gpointer user_data);
648
 
 
649
 
gboolean e_gdbus_cal_call_discard_alarm_finish (
650
 
        EGdbusCal *proxy,
651
 
        GAsyncResult *res,
652
 
        GError **error);
653
 
 
654
 
gboolean e_gdbus_cal_call_discard_alarm_sync (
655
 
        EGdbusCal *proxy,
656
 
        const gchar *in_uid,
657
 
        const gchar *in_auid,
658
 
        GCancellable *cancellable,
659
 
        GError **error);
660
 
 
661
 
void e_gdbus_cal_call_create_object (
662
 
        EGdbusCal *proxy,
663
 
        const gchar *in_calobj,
664
 
        GCancellable *cancellable,
665
 
        GAsyncReadyCallback callback,
666
 
        gpointer user_data);
667
 
 
668
 
gboolean e_gdbus_cal_call_create_object_finish (
669
 
        EGdbusCal *proxy,
670
 
        gchar **out_uid,
671
 
        GAsyncResult *res,
672
 
        GError **error);
673
 
 
674
 
gboolean e_gdbus_cal_call_create_object_sync (
675
 
        EGdbusCal *proxy,
676
 
        const gchar *in_calobj,
677
 
        gchar **out_uid,
678
 
        GCancellable *cancellable,
679
 
        GError **error);
680
 
 
681
 
void e_gdbus_cal_call_modify_object (
682
 
        EGdbusCal *proxy,
683
 
        const gchar *in_calobj,
684
 
        guint in_mod,
685
 
        GCancellable *cancellable,
686
 
        GAsyncReadyCallback callback,
687
 
        gpointer user_data);
688
 
 
689
 
gboolean e_gdbus_cal_call_modify_object_finish (
690
 
        EGdbusCal *proxy,
691
 
        GAsyncResult *res,
692
 
        GError **error);
693
 
 
694
 
gboolean e_gdbus_cal_call_modify_object_sync (
695
 
        EGdbusCal *proxy,
696
 
        const gchar *in_calobj,
697
 
        guint in_mod,
698
 
        GCancellable *cancellable,
699
 
        GError **error);
700
 
 
701
 
void e_gdbus_cal_call_remove_object (
702
 
        EGdbusCal *proxy,
703
 
        const gchar *in_uid,
704
 
        const gchar *in_rid,
705
 
        guint in_mod,
706
 
        GCancellable *cancellable,
707
 
        GAsyncReadyCallback callback,
708
 
        gpointer user_data);
709
 
 
710
 
gboolean e_gdbus_cal_call_remove_object_finish (
711
 
        EGdbusCal *proxy,
712
 
        GAsyncResult *res,
713
 
        GError **error);
714
 
 
715
 
gboolean e_gdbus_cal_call_remove_object_sync (
716
 
        EGdbusCal *proxy,
717
 
        const gchar *in_uid,
718
 
        const gchar *in_rid,
719
 
        guint in_mod,
720
 
        GCancellable *cancellable,
721
 
        GError **error);
722
 
 
723
 
void e_gdbus_cal_call_receive_objects (
724
 
        EGdbusCal *proxy,
725
 
        const gchar *in_calobj,
726
 
        GCancellable *cancellable,
727
 
        GAsyncReadyCallback callback,
728
 
        gpointer user_data);
729
 
 
730
 
gboolean e_gdbus_cal_call_receive_objects_finish (
731
 
        EGdbusCal *proxy,
732
 
        GAsyncResult *res,
733
 
        GError **error);
734
 
 
735
 
gboolean e_gdbus_cal_call_receive_objects_sync (
736
 
        EGdbusCal *proxy,
737
 
        const gchar *in_calobj,
738
 
        GCancellable *cancellable,
739
 
        GError **error);
740
 
 
741
 
void e_gdbus_cal_call_send_objects (
742
 
        EGdbusCal *proxy,
743
 
        const gchar *in_calobj,
744
 
        GCancellable *cancellable,
745
 
        GAsyncReadyCallback callback,
746
 
        gpointer user_data);
747
 
 
748
 
gboolean e_gdbus_cal_call_send_objects_finish (
749
 
        EGdbusCal *proxy,
750
 
        gchar ***out_users,
751
 
        gchar **out_calobj,
752
 
        GAsyncResult *res,
753
 
        GError **error);
754
 
 
755
 
gboolean e_gdbus_cal_call_send_objects_sync (
756
 
        EGdbusCal *proxy,
757
 
        const gchar *in_calobj,
758
 
        gchar ***out_users,
759
 
        gchar **out_calobj,
760
 
        GCancellable *cancellable,
761
 
        GError **error);
762
 
 
763
 
void e_gdbus_cal_call_get_attachment_list (
764
 
        EGdbusCal *proxy,
765
 
        const gchar *in_uid,
766
 
        const gchar *in_rid,
767
 
        GCancellable *cancellable,
768
 
        GAsyncReadyCallback callback,
769
 
        gpointer user_data);
770
 
 
771
 
gboolean e_gdbus_cal_call_get_attachment_list_finish (
772
 
        EGdbusCal *proxy,
773
 
        gchar ***out_attachments,
774
 
        GAsyncResult *res,
775
 
        GError **error);
776
 
 
777
 
gboolean e_gdbus_cal_call_get_attachment_list_sync (
778
 
        EGdbusCal *proxy,
779
 
        const gchar *in_uid,
780
 
        const gchar *in_rid,
781
 
        gchar ***out_attachments,
782
 
        GCancellable *cancellable,
783
 
        GError **error);
784
 
 
785
 
void e_gdbus_cal_call_get_query (
786
 
        EGdbusCal *proxy,
787
 
        const gchar *in_sexp,
788
 
        GCancellable *cancellable,
789
 
        GAsyncReadyCallback callback,
790
 
        gpointer user_data);
791
 
 
792
 
gboolean e_gdbus_cal_call_get_query_finish (
793
 
        EGdbusCal *proxy,
794
 
        gchar **out_query,
795
 
        GAsyncResult *res,
796
 
        GError **error);
797
 
 
798
 
gboolean e_gdbus_cal_call_get_query_sync (
799
 
        EGdbusCal *proxy,
800
 
        const gchar *in_sexp,
801
 
        gchar **out_query,
802
 
        GCancellable *cancellable,
803
 
        GError **error);
804
 
 
805
 
void e_gdbus_cal_call_get_timezone (
806
 
        EGdbusCal *proxy,
807
 
        const gchar *in_tzid,
808
 
        GCancellable *cancellable,
809
 
        GAsyncReadyCallback callback,
810
 
        gpointer user_data);
811
 
 
812
 
gboolean e_gdbus_cal_call_get_timezone_finish (
813
 
        EGdbusCal *proxy,
814
 
        gchar **out_object,
815
 
        GAsyncResult *res,
816
 
        GError **error);
817
 
 
818
 
gboolean e_gdbus_cal_call_get_timezone_sync (
819
 
        EGdbusCal *proxy,
820
 
        const gchar *in_tzid,
821
 
        gchar **out_object,
822
 
        GCancellable *cancellable,
823
 
        GError **error);
824
 
 
825
 
void e_gdbus_cal_call_add_timezone (
826
 
        EGdbusCal *proxy,
827
 
        const gchar *in_tz,
828
 
        GCancellable *cancellable,
829
 
        GAsyncReadyCallback callback,
830
 
        gpointer user_data);
831
 
 
832
 
gboolean e_gdbus_cal_call_add_timezone_finish (
833
 
        EGdbusCal *proxy,
834
 
        GAsyncResult *res,
835
 
        GError **error);
836
 
 
837
 
gboolean e_gdbus_cal_call_add_timezone_sync (
838
 
        EGdbusCal *proxy,
839
 
        const gchar *in_tz,
840
 
        GCancellable *cancellable,
841
 
        GError **error);
842
 
 
843
 
void e_gdbus_cal_call_set_default_timezone (
844
 
        EGdbusCal *proxy,
845
 
        const gchar *in_tz,
846
 
        GCancellable *cancellable,
847
 
        GAsyncReadyCallback callback,
848
 
        gpointer user_data);
849
 
 
850
 
gboolean e_gdbus_cal_call_set_default_timezone_finish (
851
 
        EGdbusCal *proxy,
852
 
        GAsyncResult *res,
853
 
        GError **error);
854
 
 
855
 
gboolean e_gdbus_cal_call_set_default_timezone_sync (
856
 
        EGdbusCal *proxy,
857
 
        const gchar *in_tz,
858
 
        GCancellable *cancellable,
859
 
        GError **error);
860
 
 
861
 
/* D-Bus Methods Completion Helpers */
862
 
void e_gdbus_cal_complete_get_uri (
863
 
        EGdbusCal *object,
864
 
        GDBusMethodInvocation *invocation,
865
 
        const gchar *out_str_uri_copy);
866
 
 
867
 
void e_gdbus_cal_complete_get_cache_dir (
868
 
        EGdbusCal *object,
869
 
        GDBusMethodInvocation *invocation,
870
 
        const gchar *out_dirname);
871
 
 
872
 
void e_gdbus_cal_complete_open (
873
 
        EGdbusCal *object,
874
 
        GDBusMethodInvocation *invocation);
875
 
 
876
 
void e_gdbus_cal_complete_refresh (
877
 
        EGdbusCal *object,
878
 
        GDBusMethodInvocation *invocation);
879
 
 
880
 
void e_gdbus_cal_complete_close (
881
 
        EGdbusCal *object,
882
 
        GDBusMethodInvocation *invocation);
883
 
 
884
 
void e_gdbus_cal_complete_remove (
885
 
        EGdbusCal *object,
886
 
        GDBusMethodInvocation *invocation);
887
 
 
888
 
void e_gdbus_cal_complete_is_read_only (
889
 
        EGdbusCal *object,
890
 
        GDBusMethodInvocation *invocation);
891
 
 
892
 
void e_gdbus_cal_complete_get_cal_address (
893
 
        EGdbusCal *object,
894
 
        GDBusMethodInvocation *invocation,
895
 
        const gchar *out_address);
896
 
 
897
 
void e_gdbus_cal_complete_get_alarm_email_address (
898
 
        EGdbusCal *object,
899
 
        GDBusMethodInvocation *invocation,
900
 
        const gchar *out_address);
901
 
 
902
 
void e_gdbus_cal_complete_get_ldap_attribute (
903
 
        EGdbusCal *object,
904
 
        GDBusMethodInvocation *invocation,
905
 
        const gchar *out_address);
906
 
 
907
 
void e_gdbus_cal_complete_get_scheduling_information (
908
 
        EGdbusCal *object,
909
 
        GDBusMethodInvocation *invocation,
910
 
        const gchar *out_capabilities);
911
 
 
912
 
void e_gdbus_cal_complete_set_mode (
913
 
        EGdbusCal *object,
914
 
        GDBusMethodInvocation *invocation);
915
 
 
916
 
void e_gdbus_cal_complete_get_default_object (
917
 
        EGdbusCal *object,
918
 
        GDBusMethodInvocation *invocation,
919
 
        const gchar *out_object);
920
 
 
921
 
void e_gdbus_cal_complete_get_object (
922
 
        EGdbusCal *object,
923
 
        GDBusMethodInvocation *invocation,
924
 
        const gchar *out_object);
925
 
 
926
 
void e_gdbus_cal_complete_get_object_list (
927
 
        EGdbusCal *object,
928
 
        GDBusMethodInvocation *invocation,
929
 
        const gchar * const *out_objects);
930
 
 
931
 
void e_gdbus_cal_complete_get_changes (
932
 
        EGdbusCal *object,
933
 
        GDBusMethodInvocation *invocation,
934
 
        const gchar * const *out_additions,
935
 
        const gchar * const *out_modifications,
936
 
        const gchar * const *out_removals);
937
 
 
938
 
void e_gdbus_cal_complete_get_free_busy (
939
 
        EGdbusCal *object,
940
 
        GDBusMethodInvocation *invocation,
941
 
        const gchar * const *out_freebusy);
942
 
 
943
 
void e_gdbus_cal_complete_discard_alarm (
944
 
        EGdbusCal *object,
945
 
        GDBusMethodInvocation *invocation);
946
 
 
947
 
void e_gdbus_cal_complete_create_object (
948
 
        EGdbusCal *object,
949
 
        GDBusMethodInvocation *invocation,
950
 
        const gchar *out_uid);
951
 
 
952
 
void e_gdbus_cal_complete_modify_object (
953
 
        EGdbusCal *object,
954
 
        GDBusMethodInvocation *invocation);
955
 
 
956
 
void e_gdbus_cal_complete_remove_object (
957
 
        EGdbusCal *object,
958
 
        GDBusMethodInvocation *invocation);
959
 
 
960
 
void e_gdbus_cal_complete_receive_objects (
961
 
        EGdbusCal *object,
962
 
        GDBusMethodInvocation *invocation);
963
 
 
964
 
void e_gdbus_cal_complete_send_objects (
965
 
        EGdbusCal *object,
966
 
        GDBusMethodInvocation *invocation,
967
 
        const gchar * const *out_users,
968
 
        const gchar *out_calobj);
969
 
 
970
 
void e_gdbus_cal_complete_get_attachment_list (
971
 
        EGdbusCal *object,
972
 
        GDBusMethodInvocation *invocation,
973
 
        const gchar * const *out_attachments);
974
 
 
975
 
void e_gdbus_cal_complete_get_query (
976
 
        EGdbusCal *object,
977
 
        GDBusMethodInvocation *invocation,
978
 
        const gchar *out_query);
979
 
 
980
 
void e_gdbus_cal_complete_get_timezone (
981
 
        EGdbusCal *object,
982
 
        GDBusMethodInvocation *invocation,
983
 
        const gchar *out_object);
984
 
 
985
 
void e_gdbus_cal_complete_add_timezone (
986
 
        EGdbusCal *object,
987
 
        GDBusMethodInvocation *invocation);
988
 
 
989
 
void e_gdbus_cal_complete_set_default_timezone (
990
 
        EGdbusCal *object,
991
 
        GDBusMethodInvocation *invocation);
992
 
 
993
 
/* D-Bus Signal Emission Helpers */
994
 
void e_gdbus_cal_emit_auth_required (
995
 
        EGdbusCal *object);
996
 
 
997
 
void e_gdbus_cal_emit_backend_error (
998
 
        EGdbusCal *object,
999
 
        const gchar *arg_error);
1000
 
 
1001
 
void e_gdbus_cal_emit_readonly (
1002
 
        EGdbusCal *object,
1003
 
        gboolean arg_is_readonly);
1004
 
 
1005
 
void e_gdbus_cal_emit_mode (
1006
 
        EGdbusCal *object,
1007
 
        gint arg_mode);
1008
 
 
1009
 
G_END_DECLS
1010
 
 
1011
 
#endif /* __E_GDBUS_E_GDBUS_CAL_H__ */