← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to calendar/libedata-cal/e-data-cal.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
calendar/libedata-cal/e-data-cal.c
 
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
1
2
/* Evolution calendar client interface object
2
3
 *
3
4
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 
5
 * Copyright (C) 2009 Intel Corporation
4
6
 *
5
7
 * Authors: Federico Mena-Quintero <federico@ximian.com>
6
8
 *          Rodrigo Moya <rodrigo@ximian.com>
 
9
 *          Ross Burton <ross@linux.intel.com>
7
10
 *
8
11
 * This program is free software; you can redistribute it and/or
9
12
 * modify it under the terms of version 2 of the GNU Lesser General Public
24
27
#endif
25
28
 
26
29
#include <libical/ical.h>
27
 
#include <bonobo/bonobo-main.h>
28
 
#include <bonobo/bonobo-exception.h>
29
 
#include <libedata-cal/e-cal-backend.h>
 
30
#include <glib/gi18n-lib.h>
 
31
#include <unistd.h>
 
32
 
 
33
#include <dbus/dbus.h>
 
34
#include <dbus/dbus-glib.h>
 
35
#include <glib-object.h>
 
36
 
30
37
#include "e-data-cal.h"
31
 
 
32
 
#define PARENT_TYPE         BONOBO_TYPE_OBJECT
33
 
 
34
 
static BonoboObjectClass *parent_class;
35
 
 
36
 
/* Private part of the Cal structure */
 
38
#include "e-data-cal-enumtypes.h"
 
39
 
 
40
DBusGConnection *connection;
 
41
 
 
42
/* DBus glue */
 
43
static void impl_Cal_get_uri (EDataCal *cal, DBusGMethodInvocation *context);
 
44
static void impl_Cal_open (EDataCal *cal, gboolean only_if_exists, gchar *username, gchar *password, DBusGMethodInvocation *context);
 
45
static gboolean impl_Cal_close (EDataCal *cal, GError **error);
 
46
static void impl_Cal_refresh (EDataCal *cal, DBusGMethodInvocation *context);
 
47
static void impl_Cal_remove (EDataCal *cal, DBusGMethodInvocation *context);
 
48
static void impl_Cal_isReadOnly (EDataCal *cal, DBusGMethodInvocation *context);
 
49
static void impl_Cal_getCalAddress (EDataCal *cal, DBusGMethodInvocation *context);
 
50
static void impl_Cal_getAlarmEmailAddress (EDataCal *cal, DBusGMethodInvocation *context);
 
51
static void impl_Cal_getLdapAttribute (EDataCal *cal, DBusGMethodInvocation *context);
 
52
static void impl_Cal_getStaticCapabilities (EDataCal *cal, DBusGMethodInvocation *context);
 
53
static void impl_Cal_setMode (EDataCal *cal, EDataCalMode mode, DBusGMethodInvocation *context);
 
54
static void impl_Cal_getDefaultObject (EDataCal *cal, DBusGMethodInvocation *context);
 
55
static void impl_Cal_getObject (EDataCal *cal, const gchar *uid, const gchar *rid, DBusGMethodInvocation *context);
 
56
static void impl_Cal_getObjectList (EDataCal *cal, const gchar *sexp, DBusGMethodInvocation *context);
 
57
static void impl_Cal_getChanges (EDataCal *cal, const gchar *change_id, DBusGMethodInvocation *context);
 
58
static void impl_Cal_getFreeBusy (EDataCal *cal, const gchar **user_list, const gulong start, const gulong end, DBusGMethodInvocation *context);
 
59
static void impl_Cal_discardAlarm (EDataCal *cal, const gchar *uid, const gchar *auid, DBusGMethodInvocation *context);
 
60
static void impl_Cal_createObject (EDataCal *cal, const gchar *calobj, DBusGMethodInvocation *context);
 
61
static void impl_Cal_modifyObject (EDataCal *cal, const gchar *calobj, const EDataCalObjModType mod, DBusGMethodInvocation *context);
 
62
static void impl_Cal_removeObject (EDataCal *cal, const gchar *uid, const gchar *rid, const EDataCalObjModType mod, DBusGMethodInvocation *context);
 
63
static void impl_Cal_receiveObjects (EDataCal *cal, const gchar *calobj, DBusGMethodInvocation *context);
 
64
static void impl_Cal_sendObjects (EDataCal *cal, const gchar *calobj, DBusGMethodInvocation *context);
 
65
static void impl_Cal_getAttachmentList (EDataCal *cal, gchar *uid, gchar *rid, DBusGMethodInvocation *context);
 
66
static void impl_Cal_getQuery (EDataCal *cal, const gchar *sexp, DBusGMethodInvocation *context);
 
67
static void impl_Cal_getTimezone (EDataCal *cal, const gchar *tzid, DBusGMethodInvocation *context);
 
68
static void impl_Cal_addTimezone (EDataCal *cal, const gchar *tz, DBusGMethodInvocation *context);
 
69
static void impl_Cal_setDefaultTimezone (EDataCal *cal, const gchar *tz, DBusGMethodInvocation *context);
 
70
#include "e-data-cal-glue.h"
 
71
 
 
72
enum
 
73
{
 
74
  AUTH_REQUIRED,
 
75
  BACKEND_ERROR,
 
76
  READ_ONLY,
 
77
  MODE,
 
78
  LAST_SIGNAL
 
79
};
 
80
 
 
81
static guint signals[LAST_SIGNAL] = { 0 };
 
82
 
 
83
G_DEFINE_TYPE (EDataCal, e_data_cal, G_TYPE_OBJECT);
 
84
 
 
85
#define E_DATA_CAL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), E_TYPE_DATA_CAL, EDataCalPrivate))
 
86
 
37
87
struct _EDataCalPrivate {
38
 
        /* Our backend */
39
88
        ECalBackend *backend;
40
 
 
41
 
        /* Listener on the client we notify */
42
 
        GNOME_Evolution_Calendar_CalListener listener;
43
 
 
44
 
        /* Cache of live queries */
 
89
        ESource *source;
45
90
        GHashTable *live_queries;
46
91
};
47
92
 
48
 
/* Cal::get_uri method */
49
 
static CORBA_char *
50
 
impl_Cal_get_uri (PortableServer_Servant servant,
51
 
                  CORBA_Environment *ev)
52
 
{
53
 
        EDataCal *cal;
54
 
        EDataCalPrivate *priv;
55
 
        const gchar *str_uri;
56
 
        CORBA_char *str_uri_copy;
57
 
 
58
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
59
 
        priv = cal->priv;
60
 
 
61
 
        str_uri = e_cal_backend_get_uri (priv->backend);
62
 
        str_uri_copy = CORBA_string_dup (str_uri);
63
 
 
64
 
        return str_uri_copy;
65
 
}
66
 
 
67
 
static void
68
 
impl_Cal_open (PortableServer_Servant servant,
69
 
               CORBA_boolean only_if_exists,
70
 
               const CORBA_char *username,
71
 
               const CORBA_char *password,
72
 
               CORBA_Environment *ev)
73
 
{
74
 
        EDataCal *cal;
75
 
        EDataCalPrivate *priv;
76
 
 
77
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
78
 
        priv = cal->priv;
79
 
 
80
 
        e_cal_backend_open (priv->backend, cal, only_if_exists, username, password);
81
 
}
82
 
 
83
 
static void
84
 
impl_Cal_remove (PortableServer_Servant servant,
85
 
                 CORBA_Environment *ev)
86
 
{
87
 
        EDataCal *cal;
88
 
        EDataCalPrivate *priv;
89
 
 
90
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
91
 
        priv = cal->priv;
92
 
 
93
 
        e_cal_backend_remove (priv->backend, cal);
94
 
}
95
 
 
96
 
/* Cal::isReadOnly method */
97
 
static void
98
 
impl_Cal_isReadOnly (PortableServer_Servant servant,
99
 
                     CORBA_Environment *ev)
100
 
{
101
 
        EDataCal *cal;
102
 
        EDataCalPrivate *priv;
103
 
 
104
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
105
 
        priv = cal->priv;
106
 
 
107
 
        e_cal_backend_is_read_only (priv->backend, cal);
108
 
}
109
 
 
110
 
/* Cal::getEmailAddress method */
111
 
static void
112
 
impl_Cal_getCalAddress (PortableServer_Servant servant,
113
 
                        CORBA_Environment *ev)
114
 
{
115
 
        EDataCal *cal;
116
 
        EDataCalPrivate *priv;
117
 
 
118
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
119
 
        priv = cal->priv;
120
 
 
121
 
        e_cal_backend_get_cal_address (priv->backend, cal);
122
 
}
123
 
 
124
 
/* Cal::get_alarm_email_address method */
125
 
static void
126
 
impl_Cal_getAlarmEmailAddress (PortableServer_Servant servant,
127
 
                               CORBA_Environment *ev)
128
 
{
129
 
        EDataCal *cal;
130
 
        EDataCalPrivate *priv;
131
 
 
132
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
133
 
        priv = cal->priv;
134
 
 
135
 
        e_cal_backend_get_alarm_email_address (priv->backend, cal);
136
 
}
137
 
 
138
 
/* Cal::get_ldap_attribute method */
139
 
static void
140
 
impl_Cal_getLdapAttribute (PortableServer_Servant servant,
141
 
                           CORBA_Environment *ev)
142
 
{
143
 
        EDataCal *cal;
144
 
        EDataCalPrivate *priv;
145
 
 
146
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
147
 
        priv = cal->priv;
148
 
 
149
 
        e_cal_backend_get_ldap_attribute (priv->backend, cal);
150
 
}
151
 
 
152
 
/* Cal::getSchedulingInformation method */
153
 
static void
154
 
impl_Cal_getStaticCapabilities (PortableServer_Servant servant,
155
 
                                CORBA_Environment *ev)
156
 
{
157
 
        EDataCal *cal;
158
 
        EDataCalPrivate *priv;
159
 
 
160
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
161
 
        priv = cal->priv;
162
 
 
163
 
        e_cal_backend_get_static_capabilities (priv->backend, cal);
164
 
}
165
 
 
166
 
/* Cal::setMode method */
167
 
static void
168
 
impl_Cal_setMode (PortableServer_Servant servant,
169
 
                  GNOME_Evolution_Calendar_CalMode mode,
170
 
                  CORBA_Environment *ev)
171
 
{
172
 
        EDataCal *cal;
173
 
        EDataCalPrivate *priv;
174
 
 
175
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
176
 
        priv = cal->priv;
177
 
 
178
 
        e_cal_backend_set_mode (priv->backend, mode);
179
 
}
180
 
 
181
 
static void
182
 
impl_Cal_getDefaultObject (PortableServer_Servant servant,
183
 
                           CORBA_Environment *ev)
184
 
{
185
 
        EDataCal *cal;
186
 
        EDataCalPrivate *priv;
187
 
 
188
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
189
 
        priv = cal->priv;
190
 
 
191
 
        e_cal_backend_get_default_object (priv->backend, cal);
192
 
}
193
 
 
194
 
/* Cal::getObject method */
195
 
static void
196
 
impl_Cal_getObject (PortableServer_Servant servant,
197
 
                    const CORBA_char *uid,
198
 
                    const CORBA_char *rid,
199
 
                    CORBA_Environment *ev)
200
 
{
201
 
        EDataCal *cal;
202
 
        EDataCalPrivate *priv;
203
 
 
204
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
205
 
        priv = cal->priv;
206
 
 
207
 
        e_cal_backend_get_object (priv->backend, cal, uid, rid);
208
 
}
209
 
 
210
 
/* Cal::getObjectList method */
211
 
static void
212
 
impl_Cal_getObjectList (PortableServer_Servant servant,
213
 
                        const CORBA_char *sexp,
214
 
                        CORBA_Environment *ev)
215
 
{
216
 
        EDataCal *cal;
217
 
        EDataCalPrivate *priv;
218
 
        EDataCalView *query;
219
 
 
220
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
221
 
        priv = cal->priv;
222
 
 
223
 
        query = g_hash_table_lookup (priv->live_queries, sexp);
224
 
        if (query) {
225
 
                GList *matched_objects;
226
 
 
227
 
                matched_objects = e_data_cal_view_get_matched_objects (query);
228
 
                e_data_cal_notify_object_list (
229
 
                        cal,
230
 
                        e_data_cal_view_is_done (query) ? e_data_cal_view_get_done_status (query) : GNOME_Evolution_Calendar_Success,
231
 
                        matched_objects);
232
 
 
233
 
                g_list_free (matched_objects);
234
 
        } else
235
 
                e_cal_backend_get_object_list (priv->backend, cal, sexp);
236
 
}
237
 
 
238
 
/* Cal::getAttachmentList method */
239
 
static void
240
 
impl_Cal_getAttachmentList (PortableServer_Servant servant,
241
 
                    const CORBA_char *uid,
242
 
                    const CORBA_char *rid,
243
 
                    CORBA_Environment *ev)
244
 
{
245
 
        EDataCal *cal;
246
 
        EDataCalPrivate *priv;
247
 
 
248
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
249
 
        priv = cal->priv;
250
 
 
251
 
        e_cal_backend_get_attachment_list (priv->backend, cal, uid, rid);
252
 
}
253
 
 
254
 
/* Cal::getChanges method */
255
 
static void
256
 
impl_Cal_getChanges (PortableServer_Servant servant,
257
 
                     const CORBA_char *change_id,
258
 
                     CORBA_Environment *ev)
259
 
{
260
 
       EDataCal *cal;
261
 
       EDataCalPrivate *priv;
262
 
 
263
 
       cal = E_DATA_CAL (bonobo_object_from_servant (servant));
264
 
       priv = cal->priv;
265
 
 
266
 
       e_cal_backend_get_changes (priv->backend, cal, change_id);
267
 
}
268
 
 
269
 
/* Cal::getFreeBusy method */
270
 
static void
271
 
impl_Cal_getFreeBusy (PortableServer_Servant servant,
272
 
                      const GNOME_Evolution_Calendar_UserList *user_list,
273
 
                      const GNOME_Evolution_Calendar_Time_t start,
274
 
                      const GNOME_Evolution_Calendar_Time_t end,
275
 
                      CORBA_Environment *ev)
276
 
{
277
 
        EDataCal *cal;
278
 
        EDataCalPrivate *priv;
 
93
/* Create the EDataCal error quark */
 
94
GQuark
 
95
e_data_cal_error_quark (void)
 
96
{
 
97
  static GQuark quark = 0;
 
98
  if (!quark)
 
99
    quark = g_quark_from_static_string ("e_data_cal_error");
 
100
  return quark;
 
101
}
 
102
 
 
103
/* Class init */
 
104
static void
 
105
e_data_cal_class_init (EDataCalClass *e_data_cal_class)
 
106
{
 
107
        /* TODO: finalise dispose */
 
108
 
 
109
        g_type_class_add_private (e_data_cal_class, sizeof (EDataCalPrivate));
 
110
 
 
111
        signals[AUTH_REQUIRED] =
 
112
          g_signal_new ("auth-required",
 
113
                                                G_OBJECT_CLASS_TYPE (e_data_cal_class),
 
114
                                                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 
115
                                                0,
 
116
                                                NULL, NULL,
 
117
                                                g_cclosure_marshal_VOID__VOID,
 
118
                                                G_TYPE_NONE, 0);
 
119
        signals[BACKEND_ERROR] =
 
120
          g_signal_new ("backend-error",
 
121
                                                G_OBJECT_CLASS_TYPE (e_data_cal_class),
 
122
                                                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 
123
                                                0,
 
124
                                                NULL, NULL,
 
125
                                                g_cclosure_marshal_VOID__STRING,
 
126
                                                G_TYPE_NONE, 1, G_TYPE_STRING);
 
127
        signals[READ_ONLY] =
 
128
          g_signal_new ("readonly",
 
129
                                                G_OBJECT_CLASS_TYPE (e_data_cal_class),
 
130
                                                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 
131
                                                0,
 
132
                                                NULL, NULL,
 
133
                                                g_cclosure_marshal_VOID__BOOLEAN,
 
134
                                                G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 
135
        signals[MODE] =
 
136
          g_signal_new ("mode",
 
137
                                                G_OBJECT_CLASS_TYPE (e_data_cal_class),
 
138
                                                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 
139
                                                0,
 
140
                                                NULL, NULL,
 
141
                                                g_cclosure_marshal_VOID__INT,
 
142
                                                G_TYPE_NONE, 1, G_TYPE_INT);
 
143
 
 
144
        dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (e_data_cal_class), &dbus_glib_e_data_cal_object_info);
 
145
 
 
146
        dbus_g_error_domain_register (E_DATA_CAL_ERROR, NULL, E_TYPE_DATA_CAL_CALL_STATUS);
 
147
}
 
148
 
 
149
/* Instance init */
 
150
static void
 
151
e_data_cal_init (EDataCal *ecal)
 
152
{
 
153
        ecal->priv = E_DATA_CAL_GET_PRIVATE (ecal);
 
154
}
 
155
 
 
156
EDataCal *
 
157
e_data_cal_new (ECalBackend *backend, ESource *source)
 
158
{
 
159
        EDataCal *cal;
 
160
        cal = g_object_new (E_TYPE_DATA_CAL, NULL);
 
161
        cal->priv->backend = backend;
 
162
        cal->priv->source = source;
 
163
        return cal;
 
164
}
 
165
 
 
166
/**
 
167
 * e_data_cal_get_source:
 
168
 * @cal: an #EDataCal
 
169
 *
 
170
 * Returns the #ESource for @cal.
 
171
 *
 
172
 * Returns: the #ESource for @cal
 
173
 *
 
174
 * Since: 2.30
 
175
 **/
 
176
ESource*
 
177
e_data_cal_get_source (EDataCal *cal)
 
178
{
 
179
  return cal->priv->source;
 
180
}
 
181
 
 
182
ECalBackend*
 
183
e_data_cal_get_backend (EDataCal *cal)
 
184
{
 
185
  return cal->priv->backend;
 
186
}
 
187
 
 
188
/* EDataCal::getUri method */
 
189
static void
 
190
impl_Cal_get_uri (EDataCal *cal, DBusGMethodInvocation *context)
 
191
{
 
192
        dbus_g_method_return (context, g_strdup (e_cal_backend_get_uri (cal->priv->backend)));
 
193
}
 
194
 
 
195
/* EDataCal::open method */
 
196
static void
 
197
impl_Cal_open (EDataCal *cal,
 
198
               gboolean only_if_exists,
 
199
               gchar *username,
 
200
               gchar *password, DBusGMethodInvocation *context)
 
201
{
 
202
        e_cal_backend_open (cal->priv->backend, cal, context, only_if_exists, username, password);
 
203
}
 
204
 
 
205
/* EDataCal::close method */
 
206
static gboolean
 
207
impl_Cal_close (EDataCal *cal, GError **error)
 
208
{
 
209
        e_cal_backend_remove_client (cal->priv->backend, cal);
 
210
        g_object_unref (cal);
 
211
        return TRUE;
 
212
}
 
213
 
 
214
/* EDataCal::refresh method */
 
215
static void
 
216
impl_Cal_refresh (EDataCal *cal, DBusGMethodInvocation *context)
 
217
{
 
218
        e_cal_backend_refresh (cal->priv->backend, cal, context);
 
219
}
 
220
 
 
221
/* EDataCal::remove method */
 
222
static void
 
223
impl_Cal_remove (EDataCal *cal, DBusGMethodInvocation *context)
 
224
{
 
225
        e_cal_backend_remove (cal->priv->backend, cal, context);
 
226
}
 
227
 
 
228
/* EDataCal::isReadOnly method */
 
229
static void
 
230
impl_Cal_isReadOnly (EDataCal *cal, DBusGMethodInvocation *context)
 
231
{
 
232
        e_cal_backend_is_read_only (cal->priv->backend, cal);
 
233
        dbus_g_method_return (context);
 
234
}
 
235
 
 
236
/* EDataCal::getCalAddress method */
 
237
static void
 
238
impl_Cal_getCalAddress (EDataCal *cal, DBusGMethodInvocation *context)
 
239
{
 
240
        e_cal_backend_get_cal_address (cal->priv->backend, cal, context);
 
241
}
 
242
 
 
243
/* EDataCal::getAlarmEmailAddress method */
 
244
static void
 
245
impl_Cal_getAlarmEmailAddress (EDataCal *cal, DBusGMethodInvocation *context)
 
246
{
 
247
        e_cal_backend_get_alarm_email_address (cal->priv->backend, cal, context);
 
248
}
 
249
 
 
250
/* EDataCal::getLdapAttribute method */
 
251
static void
 
252
impl_Cal_getLdapAttribute (EDataCal *cal, DBusGMethodInvocation *context)
 
253
{
 
254
        e_cal_backend_get_ldap_attribute (cal->priv->backend, cal, context);
 
255
}
 
256
 
 
257
/* EDataCal::getSchedulingInformation method */
 
258
static void
 
259
impl_Cal_getStaticCapabilities (EDataCal *cal, DBusGMethodInvocation *context)
 
260
{
 
261
        e_cal_backend_get_static_capabilities (cal->priv->backend, cal, context);
 
262
}
 
263
 
 
264
/* EDataCal::setMode method */
 
265
static void
 
266
impl_Cal_setMode (EDataCal *cal,
 
267
                  EDataCalMode mode,
 
268
                  DBusGMethodInvocation *context)
 
269
{
 
270
        e_cal_backend_set_mode (cal->priv->backend, mode);
 
271
        dbus_g_method_return (context);
 
272
}
 
273
 
 
274
/* EDataCal::getDefaultObject method */
 
275
static void
 
276
impl_Cal_getDefaultObject (EDataCal *cal, DBusGMethodInvocation *context)
 
277
{
 
278
        e_cal_backend_get_default_object (cal->priv->backend, cal, context);
 
279
}
 
280
 
 
281
/* EDataCal::getObject method */
 
282
static void
 
283
impl_Cal_getObject (EDataCal *cal,
 
284
                    const gchar *uid,
 
285
                    const gchar *rid,
 
286
                    DBusGMethodInvocation *context)
 
287
{
 
288
        e_cal_backend_get_object (cal->priv->backend, cal, context, uid, rid);
 
289
}
 
290
 
 
291
/* EDataCal::getObjectList method */
 
292
static void
 
293
impl_Cal_getObjectList (EDataCal *cal,
 
294
                        const gchar *sexp,
 
295
                        DBusGMethodInvocation *context)
 
296
{
 
297
                e_cal_backend_get_object_list (cal->priv->backend, cal, context, sexp);
 
298
}
 
299
 
 
300
/* EDataCal::getChanges method */
 
301
static void
 
302
impl_Cal_getChanges (EDataCal *cal,
 
303
                     const gchar *change_id,
 
304
                     DBusGMethodInvocation *context)
 
305
{
 
306
       e_cal_backend_get_changes (cal->priv->backend, cal, context, change_id);
 
307
}
 
308
 
 
309
/* EDataCal::getFreeBusy method */
 
310
static void
 
311
impl_Cal_getFreeBusy (EDataCal *cal,
 
312
                      const gchar **user_list,
 
313
                      const gulong start,
 
314
                      const gulong end,
 
315
                      DBusGMethodInvocation *context)
 
316
{
279
317
        GList *users = NULL;
280
318
 
281
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
282
 
        priv = cal->priv;
283
 
 
284
 
        /* convert the CORBA user list to a GList */
285
319
        if (user_list) {
286
320
                gint i;
287
321
 
288
 
                for (i = 0; i < user_list->_length; i++)
289
 
                        users = g_list_append (users, user_list->_buffer[i]);
 
322
                for (i = 0; user_list[i]; i++)
 
323
                        users = g_list_append (users, (gpointer)user_list[i]);
290
324
        }
291
325
 
292
326
        /* call the backend's get_free_busy method */
293
 
        e_cal_backend_get_free_busy (priv->backend, cal, users, start, end);
294
 
}
295
 
 
296
 
/* Cal::discardAlarm method */
297
 
static void
298
 
impl_Cal_discardAlarm (PortableServer_Servant servant,
299
 
                       const CORBA_char *uid,
300
 
                       const CORBA_char *auid,
301
 
                       CORBA_Environment *ev)
302
 
{
303
 
        EDataCal *cal;
304
 
        EDataCalPrivate *priv;
305
 
 
306
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
307
 
        priv = cal->priv;
308
 
 
309
 
        e_cal_backend_discard_alarm (priv->backend, cal, uid, auid);
310
 
}
311
 
 
312
 
static void
313
 
impl_Cal_createObject (PortableServer_Servant servant,
314
 
                       const CORBA_char *calobj,
315
 
                       CORBA_Environment *ev)
316
 
{
317
 
        EDataCal *cal;
318
 
        EDataCalPrivate *priv;
319
 
 
320
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
321
 
        priv = cal->priv;
322
 
 
323
 
        e_cal_backend_create_object (priv->backend, cal, calobj);
324
 
}
325
 
 
326
 
static void
327
 
impl_Cal_modifyObject (PortableServer_Servant servant,
328
 
                       const CORBA_char *calobj,
329
 
                       const GNOME_Evolution_Calendar_CalObjModType mod,
330
 
                       CORBA_Environment *ev)
331
 
{
332
 
        EDataCal *cal;
333
 
        EDataCalPrivate *priv;
334
 
 
335
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
336
 
        priv = cal->priv;
337
 
 
338
 
        e_cal_backend_modify_object (priv->backend, cal, calobj, mod);
339
 
}
340
 
 
341
 
/* Cal::removeObject method */
342
 
static void
343
 
impl_Cal_removeObject (PortableServer_Servant servant,
344
 
                       const CORBA_char *uid,
345
 
                       const CORBA_char *rid,
346
 
                       const GNOME_Evolution_Calendar_CalObjModType mod,
347
 
                       CORBA_Environment *ev)
348
 
{
349
 
        EDataCal *cal;
350
 
        EDataCalPrivate *priv;
351
 
 
352
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
353
 
        priv = cal->priv;
354
 
 
355
 
        e_cal_backend_remove_object (priv->backend, cal, uid, rid, mod);
356
 
}
357
 
 
358
 
static void
359
 
impl_Cal_receiveObjects (PortableServer_Servant servant,
360
 
                         const CORBA_char *calobj,
361
 
                         CORBA_Environment *ev)
362
 
{
363
 
        EDataCal *cal;
364
 
        EDataCalPrivate *priv;
365
 
 
366
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
367
 
        priv = cal->priv;
368
 
 
369
 
        e_cal_backend_receive_objects (priv->backend, cal, calobj);
370
 
}
371
 
 
372
 
static void
373
 
impl_Cal_sendObjects (PortableServer_Servant servant,
374
 
                      const CORBA_char *calobj,
375
 
                      CORBA_Environment *ev)
376
 
{
377
 
        EDataCal *cal;
378
 
        EDataCalPrivate *priv;
379
 
 
380
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
381
 
        priv = cal->priv;
382
 
 
383
 
        e_cal_backend_send_objects (priv->backend, cal, calobj);
384
 
}
385
 
 
386
 
static void
387
 
disconnect_query (gpointer key, EDataCalView *query, EDataCal *cal)
388
 
{
389
 
        g_signal_handlers_disconnect_matched (query, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, cal);
390
 
        e_cal_backend_remove_query (cal->priv->backend, query);
391
 
}
392
 
 
393
 
static void
394
 
query_last_listener_gone_cb (EDataCalView *query, EDataCal *cal)
395
 
{
396
 
        EDataCalPrivate *priv;
397
 
 
398
 
        g_return_if_fail (cal != NULL);
399
 
 
400
 
        priv = cal->priv;
401
 
 
402
 
        disconnect_query (NULL, query, cal);
403
 
        g_hash_table_remove (priv->live_queries, e_data_cal_view_get_text (query));
404
 
}
405
 
 
406
 
/* Cal::getQuery implementation */
407
 
static void
408
 
impl_Cal_getQuery (PortableServer_Servant servant,
409
 
                   const CORBA_char *sexp,
410
 
                   GNOME_Evolution_Calendar_CalViewListener ql,
411
 
                   CORBA_Environment *ev)
412
 
{
413
 
 
414
 
        EDataCal *cal;
415
 
        EDataCalPrivate *priv;
 
327
        e_cal_backend_get_free_busy (cal->priv->backend, cal, context, users, (time_t)start, (time_t)end);
 
328
}
 
329
 
 
330
/* EDataCal::discardAlarm method */
 
331
static void
 
332
impl_Cal_discardAlarm (EDataCal *cal,
 
333
                       const gchar *uid,
 
334
                       const gchar *auid,
 
335
                       DBusGMethodInvocation *context)
 
336
{
 
337
        e_cal_backend_discard_alarm (cal->priv->backend, cal, context, uid, auid);
 
338
}
 
339
 
 
340
/* EDataCal::createObject method */
 
341
static void
 
342
impl_Cal_createObject (EDataCal *cal,
 
343
                       const gchar *calobj,
 
344
                       DBusGMethodInvocation *context)
 
345
{
 
346
        e_cal_backend_create_object (cal->priv->backend, cal, context, calobj);
 
347
}
 
348
 
 
349
/* EDataCal::modifyObject method */
 
350
static void
 
351
impl_Cal_modifyObject (EDataCal *cal,
 
352
                       const gchar *calobj,
 
353
                       const EDataCalObjModType mod,
 
354
                       DBusGMethodInvocation *context)
 
355
{
 
356
        e_cal_backend_modify_object (cal->priv->backend, cal, context, calobj, mod);
 
357
}
 
358
 
 
359
/* EDataCal::removeObject method */
 
360
static void
 
361
impl_Cal_removeObject (EDataCal *cal,
 
362
                       const gchar *uid,
 
363
                       const gchar *rid,
 
364
                       const EDataCalObjModType mod,
 
365
                       DBusGMethodInvocation *context)
 
366
{
 
367
        if (rid[0] == '\0')
 
368
                rid = NULL;
 
369
 
 
370
        e_cal_backend_remove_object (cal->priv->backend, cal, context, uid, rid, mod);
 
371
}
 
372
 
 
373
/* EDataCal::receiveObjects method */
 
374
static void
 
375
impl_Cal_receiveObjects (EDataCal *cal,
 
376
                         const gchar *calobj,
 
377
                         DBusGMethodInvocation *context)
 
378
{
 
379
        e_cal_backend_receive_objects (cal->priv->backend, cal, context, calobj);
 
380
}
 
381
 
 
382
/* EDataCal::sendObjects method */
 
383
static void
 
384
impl_Cal_sendObjects (EDataCal *cal,
 
385
                      const gchar *calobj,
 
386
                      DBusGMethodInvocation *context)
 
387
{
 
388
        e_cal_backend_send_objects (cal->priv->backend, cal, context, calobj);
 
389
}
 
390
 
 
391
/* EDataCal::getAttachmentList method */
 
392
static void
 
393
impl_Cal_getAttachmentList (EDataCal *cal,
 
394
                   gchar *uid,
 
395
                   gchar *rid,
 
396
                   DBusGMethodInvocation *context)
 
397
{
 
398
        e_cal_backend_get_attachment_list (cal->priv->backend, cal, context, uid, rid);
 
399
}
 
400
 
 
401
/* Function to get a new EDataCalView path, used by getQuery below */
 
402
static gchar *
 
403
construct_calview_path (void)
 
404
{
 
405
  static guint counter = 1;
 
406
  return g_strdup_printf ("/org/gnome/evolution/dataserver/calendar/CalView/%d/%d", getpid(), counter++);
 
407
}
 
408
 
 
409
/* EDataCal::getQuery method */
 
410
static void
 
411
impl_Cal_getQuery (EDataCal *cal,
 
412
                   const gchar *sexp,
 
413
                   DBusGMethodInvocation *context)
 
414
{
416
415
        EDataCalView *query;
417
416
        ECalBackendSExp *obj_sexp;
418
 
 
419
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
420
 
        priv = cal->priv;
421
 
 
422
 
        /* first see if we already have the query in the cache */
423
 
        query = g_hash_table_lookup (priv->live_queries, sexp);
424
 
        if (query) {
425
 
                e_data_cal_view_add_listener (query, ql);
426
 
                e_data_cal_notify_query (cal, GNOME_Evolution_Calendar_Success, query);
427
 
                return;
428
 
        }
 
417
        gchar *path;
429
418
 
430
419
        /* we handle this entirely here, since it doesn't require any
431
420
           backend involvement now that we have e_cal_view_start to
433
422
 
434
423
        obj_sexp = e_cal_backend_sexp_new (sexp);
435
424
        if (!obj_sexp) {
436
 
                e_data_cal_notify_query (cal, GNOME_Evolution_Calendar_InvalidQuery, NULL);
437
 
 
 
425
                e_data_cal_notify_query (cal, context, InvalidQuery, NULL);
438
426
                return;
439
427
        }
440
428
 
441
 
        query = e_data_cal_view_new (priv->backend, ql, obj_sexp);
 
429
        path = construct_calview_path ();
 
430
        query = e_data_cal_view_new (cal->priv->backend, path, obj_sexp);
442
431
        if (!query) {
443
432
                g_object_unref (obj_sexp);
444
 
                e_data_cal_notify_query (cal, GNOME_Evolution_Calendar_OtherError, NULL);
445
 
 
 
433
                e_data_cal_notify_query (cal, context, OtherError, NULL);
446
434
                return;
447
435
        }
448
436
 
449
 
        g_signal_connect (query, "last_listener_gone", G_CALLBACK (query_last_listener_gone_cb), cal);
450
 
 
451
 
        g_hash_table_insert (priv->live_queries, g_strdup (sexp), query);
452
 
        e_cal_backend_add_query (priv->backend, query);
453
 
 
454
 
        e_data_cal_notify_query (cal, GNOME_Evolution_Calendar_Success, query);
455
 
}
456
 
 
457
 
/* Cal::getTimezone method */
458
 
static void
459
 
impl_Cal_getTimezone (PortableServer_Servant servant,
460
 
                      const CORBA_char *tzid,
461
 
                      CORBA_Environment *ev)
462
 
{
463
 
        EDataCal *cal;
464
 
        EDataCalPrivate *priv;
465
 
 
466
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
467
 
        priv = cal->priv;
468
 
 
469
 
        e_cal_backend_get_timezone (priv->backend, cal, tzid);
470
 
}
471
 
 
472
 
/* Cal::addTimezone method */
473
 
static void
474
 
impl_Cal_addTimezone (PortableServer_Servant servant,
475
 
                      const CORBA_char *tz,
476
 
                      CORBA_Environment *ev)
477
 
{
478
 
        EDataCal *cal;
479
 
        EDataCalPrivate *priv;
480
 
 
481
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
482
 
        priv = cal->priv;
483
 
 
484
 
        e_cal_backend_add_timezone (priv->backend, cal, tz);
485
 
}
486
 
 
487
 
/* Cal::setDefaultTimezone method */
488
 
static void
489
 
impl_Cal_setDefaultTimezone (PortableServer_Servant servant,
490
 
                             const CORBA_char *tz,
491
 
                             CORBA_Environment *ev)
492
 
{
493
 
        EDataCal *cal;
494
 
        EDataCalPrivate *priv;
495
 
 
496
 
        cal = E_DATA_CAL (bonobo_object_from_servant (servant));
497
 
        priv = cal->priv;
498
 
 
499
 
        e_cal_backend_set_default_zone (priv->backend, cal, tz);
500
 
}
501
 
 
502
 
/**
503
 
 * e_data_cal_construct:
504
 
 * @cal: A calendar client interface.
505
 
 * @backend: Calendar backend that this @cal presents an interface to.
506
 
 * @listener: Calendar listener for notification.
507
 
 *
508
 
 * Constructs a calendar client interface object by binding the corresponding
509
 
 * CORBA object to it.  The calendar interface is bound to the specified
510
 
 * @backend, and will notify the @listener about changes to the calendar.
511
 
 *
512
 
 * Return value: The same object as the @cal argument.
513
 
 **/
514
 
EDataCal *
515
 
e_data_cal_construct (EDataCal *cal,
516
 
                      ECalBackend *backend,
517
 
                      GNOME_Evolution_Calendar_CalListener listener)
518
 
{
519
 
        EDataCalPrivate *priv;
520
 
        CORBA_Environment ev;
521
 
 
522
 
        g_return_val_if_fail (cal != NULL, NULL);
523
 
        g_return_val_if_fail (E_IS_DATA_CAL (cal), NULL);
524
 
        g_return_val_if_fail (backend != NULL, NULL);
525
 
        g_return_val_if_fail (E_IS_CAL_BACKEND (backend), NULL);
526
 
 
527
 
        priv = cal->priv;
528
 
 
529
 
        CORBA_exception_init (&ev);
530
 
        priv->listener = CORBA_Object_duplicate (listener, &ev);
531
 
        if (BONOBO_EX (&ev)) {
532
 
                g_message ("cal_construct: could not duplicate the listener");
533
 
                priv->listener = CORBA_OBJECT_NIL;
534
 
                CORBA_exception_free (&ev);
535
 
                return NULL;
536
 
        }
537
 
 
538
 
        CORBA_exception_free (&ev);
539
 
 
540
 
        priv->backend = backend;
541
 
 
542
 
        return cal;
543
 
}
544
 
 
545
 
/**
546
 
 * e_data_cal_new:
547
 
 * @backend: A calendar backend.
548
 
 * @listener: A calendar listener.
549
 
 *
550
 
 * Creates a new calendar client interface object and binds it to the
551
 
 * specified @backend and @listener objects.
552
 
 *
553
 
 * Return value: A newly-created #EDataCal calendar client interface
554
 
 * object, or %NULL if its corresponding CORBA object could not be
555
 
 * created.
556
 
 **/
557
 
EDataCal *
558
 
e_data_cal_new (ECalBackend *backend, GNOME_Evolution_Calendar_CalListener listener)
559
 
{
560
 
        EDataCal *cal, *retval;
561
 
 
562
 
        g_return_val_if_fail (backend != NULL, NULL);
563
 
        g_return_val_if_fail (E_IS_CAL_BACKEND (backend), NULL);
564
 
 
565
 
        cal = E_DATA_CAL (g_object_new (E_TYPE_DATA_CAL,
566
 
                                 "poa", bonobo_poa_get_threaded (ORBIT_THREAD_HINT_PER_REQUEST, NULL),
567
 
                                 NULL));
568
 
 
569
 
        retval = e_data_cal_construct (cal, backend, listener);
570
 
        if (!retval) {
571
 
                g_message (G_STRLOC ": could not construct the calendar client interface");
572
 
                bonobo_object_unref (BONOBO_OBJECT (cal));
573
 
                return NULL;
574
 
        }
575
 
 
576
 
        return retval;
577
 
}
578
 
 
579
 
/**
580
 
 * e_data_cal_get_backend:
581
 
 * @cal: A calendar client interface.
582
 
 *
583
 
 * Gets the associated backend.
584
 
 *
585
 
 * Return value: An #ECalBackend.
586
 
 */
587
 
ECalBackend *
588
 
e_data_cal_get_backend (EDataCal *cal)
589
 
{
590
 
        g_return_val_if_fail (cal != NULL, NULL);
591
 
        g_return_val_if_fail (E_IS_DATA_CAL (cal), NULL);
592
 
 
593
 
        return cal->priv->backend;
594
 
}
595
 
 
596
 
/**
597
 
 * e_data_cal_get_listener:
598
 
 * @cal: A calendar client interface.
599
 
 *
600
 
 * Gets the listener associated with a calendar client interface.
601
 
 *
602
 
 * Return value: The listener.
603
 
 */
604
 
GNOME_Evolution_Calendar_CalListener
605
 
e_data_cal_get_listener (EDataCal *cal)
606
 
{
607
 
        g_return_val_if_fail (cal != NULL, NULL);
608
 
        g_return_val_if_fail (E_IS_DATA_CAL (cal), NULL);
609
 
 
610
 
        return cal->priv->listener;
611
 
}
612
 
 
613
 
/* Destroy handler for the calendar */
614
 
static void
615
 
e_data_cal_finalize (GObject *object)
616
 
{
617
 
        EDataCal *cal;
618
 
        EDataCalPrivate *priv;
619
 
        CORBA_Environment ev;
620
 
 
621
 
        g_return_if_fail (object != NULL);
622
 
        g_return_if_fail (E_IS_DATA_CAL (object));
623
 
 
624
 
        cal = E_DATA_CAL (object);
625
 
        priv = cal->priv;
626
 
 
627
 
        priv->backend = NULL;
628
 
 
629
 
        CORBA_exception_init (&ev);
630
 
        bonobo_object_release_unref (priv->listener, &ev);
631
 
        if (BONOBO_EX (&ev))
632
 
                g_message (G_STRLOC ": could not release the listener");
633
 
 
634
 
        priv->listener = NULL;
635
 
        CORBA_exception_free (&ev);
636
 
 
637
 
        g_hash_table_foreach (priv->live_queries, (GHFunc) disconnect_query, cal);
638
 
        g_hash_table_destroy (priv->live_queries);
639
 
        priv->live_queries = NULL;
640
 
 
641
 
        g_free (priv);
642
 
 
643
 
        if (G_OBJECT_CLASS (parent_class)->finalize)
644
 
                (* G_OBJECT_CLASS (parent_class)->finalize) (object);
645
 
}
646
 
 
647
 
 
648
 
 
649
 
/* Class initialization function for the calendar */
650
 
static void
651
 
e_data_cal_class_init (EDataCalClass *klass)
652
 
{
653
 
        GObjectClass *object_class = (GObjectClass *) klass;
654
 
        POA_GNOME_Evolution_Calendar_Cal__epv *epv = &klass->epv;
655
 
 
656
 
        parent_class = g_type_class_peek_parent (klass);
657
 
 
658
 
        /* Class method overrides */
659
 
        object_class->finalize = e_data_cal_finalize;
660
 
 
661
 
        /* Epv methods */
662
 
        epv->_get_uri = impl_Cal_get_uri;
663
 
        epv->open = impl_Cal_open;
664
 
        epv->remove = impl_Cal_remove;
665
 
        epv->isReadOnly = impl_Cal_isReadOnly;
666
 
        epv->getCalAddress = impl_Cal_getCalAddress;
667
 
        epv->getAlarmEmailAddress = impl_Cal_getAlarmEmailAddress;
668
 
        epv->getLdapAttribute = impl_Cal_getLdapAttribute;
669
 
        epv->getStaticCapabilities = impl_Cal_getStaticCapabilities;
670
 
        epv->setMode = impl_Cal_setMode;
671
 
        epv->getDefaultObject = impl_Cal_getDefaultObject;
672
 
        epv->getObject = impl_Cal_getObject;
673
 
        epv->getTimezone = impl_Cal_getTimezone;
674
 
        epv->addTimezone = impl_Cal_addTimezone;
675
 
        epv->setDefaultTimezone = impl_Cal_setDefaultTimezone;
676
 
        epv->getObjectList = impl_Cal_getObjectList;
677
 
        epv->getAttachmentList = impl_Cal_getAttachmentList;
678
 
        epv->getChanges = impl_Cal_getChanges;
679
 
        epv->getFreeBusy = impl_Cal_getFreeBusy;
680
 
        epv->discardAlarm = impl_Cal_discardAlarm;
681
 
        epv->createObject = impl_Cal_createObject;
682
 
        epv->modifyObject = impl_Cal_modifyObject;
683
 
        epv->removeObject = impl_Cal_removeObject;
684
 
        epv->receiveObjects = impl_Cal_receiveObjects;
685
 
        epv->sendObjects = impl_Cal_sendObjects;
686
 
        epv->getQuery = impl_Cal_getQuery;
687
 
}
688
 
 
689
 
/* Object initialization function for the calendar */
690
 
static void
691
 
e_data_cal_init (EDataCal *cal, EDataCalClass *klass)
692
 
{
693
 
        EDataCalPrivate *priv;
694
 
 
695
 
        priv = g_new0 (EDataCalPrivate, 1);
696
 
        cal->priv = priv;
697
 
 
698
 
        priv->listener = CORBA_OBJECT_NIL;
699
 
        priv->live_queries = g_hash_table_new_full (g_str_hash, g_str_equal,
700
 
                                                    (GDestroyNotify) g_free,
701
 
                                                    (GDestroyNotify) bonobo_object_unref);
702
 
}
703
 
 
704
 
BONOBO_TYPE_FUNC_FULL (EDataCal, GNOME_Evolution_Calendar_Cal, PARENT_TYPE, e_data_cal)
 
437
        e_cal_backend_add_query (cal->priv->backend, query);
 
438
 
 
439
        e_data_cal_notify_query (cal, context, Success, path);
 
440
 
 
441
        g_free (path);
 
442
}
 
443
 
 
444
/* EDataCal::getTimezone method */
 
445
static void
 
446
impl_Cal_getTimezone (EDataCal *cal,
 
447
                      const gchar *tzid,
 
448
                      DBusGMethodInvocation *context)
 
449
{
 
450
        e_cal_backend_get_timezone (cal->priv->backend, cal, context, tzid);
 
451
}
 
452
 
 
453
/* EDataCal::addTimezone method */
 
454
static void
 
455
impl_Cal_addTimezone (EDataCal *cal,
 
456
                      const gchar *tz,
 
457
                      DBusGMethodInvocation *context)
 
458
{
 
459
        e_cal_backend_add_timezone (cal->priv->backend, cal, context, tz);
 
460
}
 
461
 
 
462
/* EDataCal::setDefaultTimezone method */
 
463
static void
 
464
impl_Cal_setDefaultTimezone (EDataCal *cal,
 
465
                             const gchar *tz,
 
466
                             DBusGMethodInvocation *context)
 
467
{
 
468
        e_cal_backend_set_default_zone (cal->priv->backend, cal, context, tz);
 
469
}
705
470
 
706
471
/**
707
472
 * e_data_cal_notify_read_only:
712
477
 * Notifies listeners of the completion of the is_read_only method call.
713
478
 */
714
479
void
715
 
e_data_cal_notify_read_only (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, gboolean read_only)
 
480
e_data_cal_notify_read_only (EDataCal *cal, EDataCalCallStatus status, gboolean read_only)
716
481
{
717
 
        EDataCalPrivate *priv;
718
 
        CORBA_Environment ev;
719
 
 
720
482
        g_return_if_fail (cal != NULL);
721
483
        g_return_if_fail (E_IS_DATA_CAL (cal));
722
484
 
723
 
        priv = cal->priv;
724
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
725
 
 
726
 
        CORBA_exception_init (&ev);
727
 
        GNOME_Evolution_Calendar_CalListener_notifyReadOnly (priv->listener, status, read_only, &ev);
728
 
 
729
 
        if (BONOBO_EX (&ev))
730
 
                g_message (G_STRLOC ": could not notify the listener of read only");
731
 
 
732
 
        CORBA_exception_free (&ev);
 
485
        g_signal_emit (cal, signals[READ_ONLY], 0, read_only);
733
486
}
734
487
 
735
488
/**
741
494
 * Notifies listeners of the completion of the get_cal_address method call.
742
495
 */
743
496
void
744
 
e_data_cal_notify_cal_address (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *address)
 
497
e_data_cal_notify_cal_address (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *address)
745
498
{
746
 
        EDataCalPrivate *priv;
747
 
        CORBA_Environment ev;
748
 
 
749
 
        g_return_if_fail (cal != NULL);
750
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
751
 
 
752
 
        priv = cal->priv;
753
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
754
 
 
755
 
        CORBA_exception_init (&ev);
756
 
        GNOME_Evolution_Calendar_CalListener_notifyCalAddress (priv->listener, status, address ? address : "", &ev);
757
 
 
758
 
        if (BONOBO_EX (&ev))
759
 
                g_message (G_STRLOC ": could not notify the listener of cal address");
760
 
 
761
 
        CORBA_exception_free (&ev);
 
499
        DBusGMethodInvocation *method = context;
 
500
        if (status != Success)
 
501
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar address")));
 
502
        else
 
503
                dbus_g_method_return (method, address ? address : "");
762
504
}
763
505
 
764
506
/**
770
512
 * Notifies listeners of the completion of the get_alarm_email_address method call.
771
513
 */
772
514
void
773
 
e_data_cal_notify_alarm_email_address (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *address)
 
515
e_data_cal_notify_alarm_email_address (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *address)
774
516
{
775
 
        EDataCalPrivate *priv;
776
 
        CORBA_Environment ev;
777
 
 
778
 
        g_return_if_fail (cal != NULL);
779
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
780
 
 
781
 
        priv = cal->priv;
782
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
783
 
 
784
 
        CORBA_exception_init (&ev);
785
 
        GNOME_Evolution_Calendar_CalListener_notifyAlarmEmailAddress (priv->listener, status, address ? address : "", &ev);
786
 
 
787
 
        if (BONOBO_EX (&ev))
788
 
                g_message (G_STRLOC ": could not notify the listener of alarm address");
789
 
 
790
 
        CORBA_exception_free (&ev);
 
517
        DBusGMethodInvocation *method = context;
 
518
        if (status != Success)
 
519
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar alarm e-mail address")));
 
520
        else
 
521
                dbus_g_method_return (method, address ? address : "");
791
522
}
792
523
 
793
524
/**
799
530
 * Notifies listeners of the completion of the get_ldap_attribute method call.
800
531
 */
801
532
void
802
 
e_data_cal_notify_ldap_attribute (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *attribute)
 
533
e_data_cal_notify_ldap_attribute (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *attribute)
803
534
{
804
 
        EDataCalPrivate *priv;
805
 
        CORBA_Environment ev;
806
 
 
807
 
        g_return_if_fail (cal != NULL);
808
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
809
 
 
810
 
        priv = cal->priv;
811
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
812
 
 
813
 
        CORBA_exception_init (&ev);
814
 
        GNOME_Evolution_Calendar_CalListener_notifyLDAPAttribute (priv->listener, status, attribute ? attribute : "", &ev);
815
 
 
816
 
        if (BONOBO_EX (&ev))
817
 
                g_message (G_STRLOC ": could not notify the listener of ldap attribute");
818
 
 
819
 
        CORBA_exception_free (&ev);
 
535
        DBusGMethodInvocation *method = context;
 
536
        if (status != Success)
 
537
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar's ldap attribute")));
 
538
        else
 
539
                dbus_g_method_return (method, attribute ? attribute : "");
820
540
}
821
541
 
822
542
/**
828
548
 * Notifies listeners of the completion of the get_static_capabilities method call.
829
549
 */
830
550
void
831
 
e_data_cal_notify_static_capabilities (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *capabilities)
 
551
e_data_cal_notify_static_capabilities (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *capabilities)
832
552
{
833
 
        EDataCalPrivate *priv;
834
 
        CORBA_Environment ev;
835
 
 
836
 
        g_return_if_fail (cal != NULL);
837
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
838
 
 
839
 
        priv = cal->priv;
840
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
841
 
 
842
 
        CORBA_exception_init (&ev);
843
 
        GNOME_Evolution_Calendar_CalListener_notifyStaticCapabilities (priv->listener, status,
844
 
                                                                    capabilities ? capabilities : "", &ev);
845
 
 
846
 
        if (BONOBO_EX (&ev))
847
 
                g_message (G_STRLOC ": could not notify the listener of static capabilities");
848
 
 
849
 
        CORBA_exception_free (&ev);
 
553
        DBusGMethodInvocation *method = context;
 
554
        if (status != Success)
 
555
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar scheduling information")));
 
556
        else
 
557
                dbus_g_method_return (method, capabilities ? capabilities : "");
850
558
}
851
559
 
852
560
/**
857
565
 * Notifies listeners of the completion of the open method call.
858
566
 */
859
567
void
860
 
e_data_cal_notify_open (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status)
861
 
{
862
 
        EDataCalPrivate *priv;
863
 
        CORBA_Environment ev;
864
 
 
865
 
        g_return_if_fail (cal != NULL);
866
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
867
 
 
868
 
        priv = cal->priv;
869
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
870
 
 
871
 
        CORBA_exception_init (&ev);
872
 
        GNOME_Evolution_Calendar_CalListener_notifyCalOpened (priv->listener, status, &ev);
873
 
 
874
 
        if (BONOBO_EX (&ev))
875
 
                g_message (G_STRLOC ": could not notify the listener of open");
876
 
 
877
 
        CORBA_exception_free (&ev);
 
568
e_data_cal_notify_open (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
 
569
{
 
570
        DBusGMethodInvocation *method = context;
 
571
        if (status != Success)
 
572
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot open calendar")));
 
573
        else
 
574
                dbus_g_method_return (method);
 
575
}
 
576
 
 
577
/**
 
578
 * e_data_cal_notify_refresh:
 
579
 * @cal: A calendar client interface.
 
580
 * @status: Status code.
 
581
 *
 
582
 * Notifies listeners of the completion of the refresh method call.
 
583
 *
 
584
 * Since: 2.30
 
585
 */
 
586
void
 
587
e_data_cal_notify_refresh (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
 
588
{
 
589
        DBusGMethodInvocation *method = context;
 
590
        if (status != Success)
 
591
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot refresh calendar")));
 
592
        else
 
593
                dbus_g_method_return (method);
878
594
}
879
595
 
880
596
/**
885
601
 * Notifies listeners of the completion of the remove method call.
886
602
 */
887
603
void
888
 
e_data_cal_notify_remove (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status)
 
604
e_data_cal_notify_remove (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
889
605
{
890
 
        EDataCalPrivate *priv;
891
 
        CORBA_Environment ev;
892
 
 
893
 
        g_return_if_fail (cal != NULL);
894
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
895
 
 
896
 
        priv = cal->priv;
897
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
898
 
 
899
 
        CORBA_exception_init (&ev);
900
 
        GNOME_Evolution_Calendar_CalListener_notifyCalRemoved (priv->listener, status, &ev);
901
 
 
902
 
        if (BONOBO_EX (&ev))
903
 
                g_message (G_STRLOC ": could not notify the listener of remove");
904
 
 
905
 
        CORBA_exception_free (&ev);
 
606
        DBusGMethodInvocation *method = context;
 
607
        if (status != Success)
 
608
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot remove calendar")));
 
609
        else
 
610
                dbus_g_method_return (method);
906
611
}
907
612
 
908
613
/**
913
618
 * @object: The object created as an iCalendar string.
914
619
 *
915
620
 * Notifies listeners of the completion of the create_object method call.
916
 
 */
917
 
void
918
 
e_data_cal_notify_object_created (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status,
 
621
 */void
 
622
e_data_cal_notify_object_created (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status,
919
623
                                  const gchar *uid, const gchar *object)
920
624
{
921
 
        EDataCalPrivate *priv;
922
 
        CORBA_Environment ev;
923
 
 
924
 
        g_return_if_fail (cal != NULL);
925
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
926
 
 
927
 
        priv = cal->priv;
928
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
929
 
 
930
 
        /* If the object is NULL, it means the object has been created on the server sucessfully,
931
 
           but it is not shown in the UI if delay delivery is set */
932
 
        if (status == GNOME_Evolution_Calendar_Success && object)
933
 
                e_cal_backend_notify_object_created (priv->backend, object);
934
 
 
935
 
        CORBA_exception_init (&ev);
936
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectCreated (priv->listener, status, uid ? uid : "", &ev);
937
 
 
938
 
        if (BONOBO_EX (&ev))
939
 
                g_message (G_STRLOC ": could not notify the listener of object creation");
940
 
 
941
 
        CORBA_exception_free (&ev);
 
625
        DBusGMethodInvocation *method = context;
 
626
        if (status != Success) {
 
627
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot create calendar object")));
 
628
        } else {
 
629
                e_cal_backend_notify_object_created (cal->priv->backend, object);
 
630
                dbus_g_method_return (method, uid ? uid : "");
 
631
        }
942
632
}
943
633
 
944
634
/**
951
641
 * Notifies listeners of the completion of the modify_object method call.
952
642
 */
953
643
void
954
 
e_data_cal_notify_object_modified (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status,
 
644
e_data_cal_notify_object_modified (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status,
955
645
                                   const gchar *old_object, const gchar *object)
956
646
{
957
 
        EDataCalPrivate *priv;
958
 
        CORBA_Environment ev;
959
 
 
960
 
        g_return_if_fail (cal != NULL);
961
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
962
 
 
963
 
        priv = cal->priv;
964
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
965
 
 
966
 
        if (status == GNOME_Evolution_Calendar_Success)
967
 
                e_cal_backend_notify_object_modified (priv->backend, old_object, object);
968
 
 
969
 
        CORBA_exception_init (&ev);
970
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectModified (priv->listener, status, &ev);
971
 
 
972
 
        if (BONOBO_EX (&ev))
973
 
                g_message (G_STRLOC ": could not notify the listener of object creation");
974
 
 
975
 
        CORBA_exception_free (&ev);
 
647
        DBusGMethodInvocation *method = context;
 
648
        if (status != Success) {
 
649
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot modify calendar object")));
 
650
        } else {
 
651
                e_cal_backend_notify_object_modified (cal->priv->backend, old_object, object);
 
652
                dbus_g_method_return (method);
 
653
        }
976
654
}
977
655
 
978
656
/**
987
665
 * Notifies listeners of the completion of the remove_object method call.
988
666
 */
989
667
void
990
 
e_data_cal_notify_object_removed (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status,
 
668
e_data_cal_notify_object_removed (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status,
991
669
                                  const ECalComponentId *id, const gchar *old_object, const gchar *object)
992
670
{
993
 
        EDataCalPrivate *priv;
994
 
        CORBA_Environment ev;
995
 
 
996
 
        g_return_if_fail (cal != NULL);
997
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
998
 
 
999
 
        priv = cal->priv;
1000
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1001
 
 
1002
 
        if (status == GNOME_Evolution_Calendar_Success)
1003
 
                e_cal_backend_notify_object_removed (priv->backend, id, old_object, object);
1004
 
 
1005
 
        CORBA_exception_init (&ev);
1006
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectRemoved (priv->listener, status, &ev);
1007
 
 
1008
 
        if (BONOBO_EX (&ev))
1009
 
                g_message (G_STRLOC ": could not notify the listener of object removal");
1010
 
 
1011
 
        CORBA_exception_free (&ev);
 
671
        DBusGMethodInvocation *method = context;
 
672
        if (status != Success) {
 
673
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot remove calendar object")));
 
674
        } else {
 
675
                e_cal_backend_notify_object_removed (cal->priv->backend, id, old_object, object);
 
676
                dbus_g_method_return (method);
 
677
        }
1012
678
}
1013
679
 
1014
680
/**
1019
685
 * Notifies listeners of the completion of the receive_objects method call.
1020
686
 */
1021
687
void
1022
 
e_data_cal_notify_objects_received (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status)
 
688
e_data_cal_notify_objects_received (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
1023
689
{
1024
 
        EDataCalPrivate *priv;
1025
 
        CORBA_Environment ev;
1026
 
 
1027
 
        g_return_if_fail (cal != NULL);
1028
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1029
 
 
1030
 
        priv = cal->priv;
1031
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1032
 
 
1033
 
        CORBA_exception_init (&ev);
1034
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectsReceived (priv->listener, status, &ev);
1035
 
 
1036
 
        if (BONOBO_EX (&ev))
1037
 
                g_message (G_STRLOC ": could not notify the listener of objects received");
1038
 
 
1039
 
        CORBA_exception_free (&ev);
 
690
        DBusGMethodInvocation *method = context;
 
691
        if (status != Success)
 
692
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot receive calendar objects")));
 
693
        else
 
694
                dbus_g_method_return (method);
1040
695
}
1041
696
 
1042
697
/**
1047
702
 * Notifies listeners of the completion of the discard_alarm method call.
1048
703
 */
1049
704
void
1050
 
e_data_cal_notify_alarm_discarded (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status)
 
705
e_data_cal_notify_alarm_discarded (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
1051
706
{
1052
 
        EDataCalPrivate *priv;
1053
 
        CORBA_Environment ev;
1054
 
 
1055
 
        g_return_if_fail (cal != NULL);
1056
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1057
 
 
1058
 
        priv = cal->priv;
1059
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1060
 
 
1061
 
        CORBA_exception_init (&ev);
1062
 
        GNOME_Evolution_Calendar_CalListener_notifyAlarmDiscarded (priv->listener, status, &ev);
1063
 
 
1064
 
        if (BONOBO_EX (&ev))
1065
 
                g_message (G_STRLOC ": could not notify the listener of alarm discarded");
1066
 
 
1067
 
        CORBA_exception_free (&ev);
 
707
        DBusGMethodInvocation *method = context;
 
708
        if (status != Success)
 
709
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot discard calendar alarm")));
 
710
        else
 
711
                dbus_g_method_return (method);
1068
712
}
1069
713
 
1070
714
/**
1077
721
 * Notifies listeners of the completion of the send_objects method call.
1078
722
 */
1079
723
void
1080
 
e_data_cal_notify_objects_sent (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, GList *users, const gchar *calobj)
 
724
e_data_cal_notify_objects_sent (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, GList *users, const gchar *calobj)
1081
725
{
1082
 
        EDataCalPrivate *priv;
1083
 
        CORBA_Environment ev;
1084
 
        GNOME_Evolution_Calendar_UserList *corba_users;
1085
 
 
1086
 
        g_return_if_fail (cal != NULL);
1087
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1088
 
 
1089
 
        priv = cal->priv;
1090
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1091
 
 
1092
 
        corba_users = GNOME_Evolution_Calendar_UserList__alloc ();
1093
 
        corba_users->_length = g_list_length (users);
1094
 
        if (users) {
1095
 
                GList *l;
1096
 
                gint n;
1097
 
 
1098
 
                corba_users->_buffer = CORBA_sequence_GNOME_Evolution_Calendar_User_allocbuf (corba_users->_length);
1099
 
                for (l = users, n = 0; l != NULL; l = l->next, n++)
1100
 
                        corba_users->_buffer[n] = CORBA_string_dup (l->data);
 
726
        DBusGMethodInvocation *method = context;
 
727
        if (status != Success) {
 
728
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot send calendar objects")));
 
729
        } else {
 
730
                gchar **users_array = NULL;
 
731
 
 
732
                if (users) {
 
733
                        GList *l;
 
734
                        gchar **user;
 
735
 
 
736
                        users_array = g_new0 (gchar *, g_list_length (users)+1);
 
737
                        if (users_array)
 
738
                                for (l = users, user = users_array; l != NULL; l = l->next, user++)
 
739
                                        *user = g_strdup (l->data);
 
740
                }
 
741
                else
 
742
                        users_array = g_new0 (gchar *, 1);
 
743
 
 
744
                dbus_g_method_return (method, users_array, calobj ? calobj : "");
 
745
                if (users_array)
 
746
                        g_strfreev (users_array);
1101
747
        }
1102
 
 
1103
 
        CORBA_exception_init (&ev);
1104
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectsSent (priv->listener, status, corba_users,
1105
 
                                                                calobj ? calobj : "", &ev);
1106
 
 
1107
 
        if (BONOBO_EX (&ev))
1108
 
                g_message (G_STRLOC ": could not notify the listener of objects sent");
1109
 
 
1110
 
        CORBA_exception_free (&ev);
1111
 
        CORBA_free (corba_users);
1112
748
}
1113
749
 
1114
750
/**
1120
756
 * Notifies listeners of the completion of the get_default_object method call.
1121
757
 */
1122
758
void
1123
 
e_data_cal_notify_default_object (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *object)
 
759
e_data_cal_notify_default_object (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *object)
1124
760
{
1125
 
        EDataCalPrivate *priv;
1126
 
        CORBA_Environment ev;
1127
 
 
1128
 
        g_return_if_fail (cal != NULL);
1129
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1130
 
 
1131
 
        priv = cal->priv;
1132
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1133
 
 
1134
 
        CORBA_exception_init (&ev);
1135
 
 
1136
 
        GNOME_Evolution_Calendar_CalListener_notifyDefaultObjectRequested (priv->listener, status,
1137
 
                                                                           object ? object : "", &ev);
1138
 
 
1139
 
        if (BONOBO_EX (&ev))
1140
 
                g_message (G_STRLOC ": could not notify the listener of default object");
1141
 
 
1142
 
        CORBA_exception_free (&ev);
 
761
        DBusGMethodInvocation *method = context;
 
762
        if (status != Success)
 
763
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve default calendar object path")));
 
764
        else
 
765
                dbus_g_method_return (method, object ? object : "");
1143
766
}
1144
767
 
1145
768
/**
1151
774
 * Notifies listeners of the completion of the get_object method call.
1152
775
 */
1153
776
void
1154
 
e_data_cal_notify_object (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *object)
 
777
e_data_cal_notify_object (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *object)
1155
778
{
1156
 
        EDataCalPrivate *priv;
1157
 
        CORBA_Environment ev;
1158
 
 
1159
 
        g_return_if_fail (cal != NULL);
1160
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1161
 
 
1162
 
        priv = cal->priv;
1163
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1164
 
 
1165
 
        CORBA_exception_init (&ev);
1166
 
 
1167
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectRequested (priv->listener, status,
1168
 
                                                                    object ? object : "", &ev);
1169
 
 
1170
 
        if (BONOBO_EX (&ev))
1171
 
                g_message (G_STRLOC ": could not notify the listener of object");
1172
 
 
1173
 
        CORBA_exception_free (&ev);
 
779
        DBusGMethodInvocation *method = context;
 
780
        if (status != Success)
 
781
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar object path")));
 
782
        else
 
783
                dbus_g_method_return (method, object ? object : "");
1174
784
}
1175
785
 
1176
786
/**
1182
792
 * Notifies listeners of the completion of the get_object_list method call.
1183
793
 */
1184
794
void
1185
 
e_data_cal_notify_object_list (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, GList *objects)
 
795
e_data_cal_notify_object_list (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, GList *objects)
1186
796
{
1187
 
        EDataCalPrivate *priv;
1188
 
        CORBA_Environment ev;
1189
 
        GNOME_Evolution_Calendar_stringlist seq;
1190
 
        GList *l;
1191
 
        gint i;
1192
 
 
1193
 
        g_return_if_fail (cal != NULL);
1194
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1195
 
 
1196
 
        priv = cal->priv;
1197
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1198
 
 
1199
 
        CORBA_exception_init (&ev);
1200
 
 
1201
 
        seq._maximum = g_list_length (objects);
1202
 
        seq._length = 0;
1203
 
        seq._buffer = GNOME_Evolution_Calendar_stringlist_allocbuf (seq._maximum);
1204
 
 
1205
 
        for (l = objects, i = 0; l; l = l->next, i++) {
1206
 
                seq._buffer[i] = CORBA_string_dup (l->data);
1207
 
                seq._length++;
 
797
        DBusGMethodInvocation *method = context;
 
798
        if (status != Success) {
 
799
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar object list")));
 
800
        } else {
 
801
                gchar **seq = NULL;
 
802
                GList *l;
 
803
                gint i;
 
804
 
 
805
                seq = g_new0 (gchar *, g_list_length (objects)+1);
 
806
                for (l = objects, i = 0; l; l = l->next, i++) {
 
807
                        seq[i] = l->data;
 
808
                }
 
809
 
 
810
                dbus_g_method_return (method, seq);
 
811
 
 
812
                g_free (seq);
1208
813
        }
1209
 
 
1210
 
        GNOME_Evolution_Calendar_CalListener_notifyObjectListRequested (priv->listener, status, &seq, &ev);
1211
 
 
1212
 
        if (BONOBO_EX (&ev))
1213
 
                g_message (G_STRLOC ": could not notify the listener of object list");
1214
 
 
1215
 
        CORBA_exception_free (&ev);
1216
 
 
1217
 
        CORBA_free(seq._buffer);
1218
814
}
1219
815
 
1220
816
/**
1223
819
 * @status: Status code.
1224
820
 * @attachments: List of retrieved attachment uri's.
1225
821
 *
1226
 
 * Notifies listeners of the completion of the get_attachment_list method call.
1227
 
 */
 
822
 * Notifies listeners of the completion of the get_attachment_list method call.+ */
1228
823
void
1229
 
e_data_cal_notify_attachment_list (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, GSList *attachments)
 
824
e_data_cal_notify_attachment_list (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, GSList *attachments)
1230
825
{
1231
 
        EDataCalPrivate *priv;
1232
 
        CORBA_Environment ev;
1233
 
        GNOME_Evolution_Calendar_stringlist seq;
 
826
        DBusGMethodInvocation *method = context;
 
827
        gchar **seq;
1234
828
        GSList *l;
1235
829
        gint i;
1236
830
 
1237
 
        g_return_if_fail (cal != NULL);
1238
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1239
 
 
1240
 
        priv = cal->priv;
1241
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1242
 
 
1243
 
        CORBA_exception_init (&ev);
1244
 
 
1245
 
        seq._maximum = g_slist_length (attachments);
1246
 
        seq._length = 0;
1247
 
        seq._buffer = GNOME_Evolution_Calendar_stringlist_allocbuf (seq._maximum);
1248
 
 
 
831
        seq = g_new0 (gchar *, g_slist_length (attachments));
1249
832
        for (l = attachments, i = 0; l; l = l->next, i++) {
1250
 
                seq._buffer[i] = CORBA_string_dup (l->data);
1251
 
                seq._length++;
 
833
                seq[i] = g_strdup (l->data);
1252
834
        }
1253
835
 
1254
 
        GNOME_Evolution_Calendar_CalListener_notifyAttachmentListRequested (priv->listener, status, &seq, &ev);
1255
 
 
1256
 
        if (BONOBO_EX (&ev))
1257
 
                g_message (G_STRLOC ": could not notify the listener of object list");
1258
 
 
1259
 
        CORBA_exception_free (&ev);
1260
 
 
1261
 
        CORBA_free(seq._buffer);
 
836
        if (status != Success)
 
837
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Could not retrieve attachment list")));
 
838
        else
 
839
                dbus_g_method_return (method, seq);
1262
840
}
1263
841
 
1264
842
/**
1270
848
 * Notifies listeners of the completion of the get_query method call.
1271
849
 */
1272
850
void
1273
 
e_data_cal_notify_query (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, EDataCalView *query)
 
851
e_data_cal_notify_query (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *query)
1274
852
{
1275
 
        EDataCalPrivate *priv;
1276
 
        CORBA_Environment ev;
1277
 
 
1278
 
        g_return_if_fail (cal != NULL);
1279
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1280
 
 
1281
 
        priv = cal->priv;
1282
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1283
 
 
1284
 
        CORBA_exception_init (&ev);
1285
 
        GNOME_Evolution_Calendar_CalListener_notifyQuery (priv->listener, status, BONOBO_OBJREF (query), &ev);
1286
 
 
1287
 
        if (BONOBO_EX (&ev))
1288
 
                g_message (G_STRLOC ": could not notify the listener of query");
1289
 
 
1290
 
        CORBA_exception_free (&ev);
 
853
        /*
 
854
         * Only have a seperate notify function to follow suit with the rest of this
 
855
         * file - it'd be much easier to just do the return in the above function
 
856
         */
 
857
        DBusGMethodInvocation *method = context;
 
858
        if (status != Success)
 
859
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Could not complete calendar query")));
 
860
        else
 
861
                dbus_g_method_return (method, query);
1291
862
}
1292
863
 
1293
864
/**
1299
870
 * Notifies listeners of the completion of the get_timezone method call.
1300
871
 */
1301
872
void
1302
 
e_data_cal_notify_timezone_requested (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *object)
 
873
e_data_cal_notify_timezone_requested (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *object)
1303
874
{
1304
 
        EDataCalPrivate *priv;
1305
 
        CORBA_Environment ev;
1306
 
 
1307
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1308
 
 
1309
 
        priv = cal->priv;
1310
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1311
 
 
1312
 
        CORBA_exception_init (&ev);
1313
 
        GNOME_Evolution_Calendar_CalListener_notifyTimezoneRequested (priv->listener, status, object ? object : "", &ev);
1314
 
 
1315
 
        if (BONOBO_EX (&ev))
1316
 
                g_warning (G_STRLOC ": could not notify the listener of timezone requested");
1317
 
 
1318
 
        CORBA_exception_free (&ev);
 
875
        DBusGMethodInvocation *method = context;
 
876
        if (status != Success)
 
877
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Could not retrieve calendar time zone")));
 
878
        else
 
879
                dbus_g_method_return (method, object ? object : "");
1319
880
}
1320
881
 
1321
882
/**
1327
888
 * Notifies listeners of the completion of the add_timezone method call.
1328
889
 */
1329
890
void
1330
 
e_data_cal_notify_timezone_added (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, const gchar *tzid)
 
891
e_data_cal_notify_timezone_added (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, const gchar *tzid)
1331
892
{
1332
 
        EDataCalPrivate *priv;
1333
 
        CORBA_Environment ev;
1334
 
 
1335
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1336
 
 
1337
 
        priv = cal->priv;
1338
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1339
 
 
1340
 
        CORBA_exception_init (&ev);
1341
 
        GNOME_Evolution_Calendar_CalListener_notifyTimezoneAdded (priv->listener, status, tzid ? tzid : "", &ev);
1342
 
 
1343
 
        if (BONOBO_EX (&ev))
1344
 
                g_warning (G_STRLOC ": could not notify the listener of timezone added");
1345
 
 
1346
 
        CORBA_exception_free (&ev);
 
893
        DBusGMethodInvocation *method = context;
 
894
        if (status != Success)
 
895
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Could not add calendar time zone")));
 
896
        else
 
897
                dbus_g_method_return (method, tzid ? tzid : "");
1347
898
}
1348
899
 
1349
900
/**
1354
905
 * Notifies listeners of the completion of the set_default_timezone method call.
1355
906
 */
1356
907
void
1357
 
e_data_cal_notify_default_timezone_set (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status)
 
908
e_data_cal_notify_default_timezone_set (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status)
1358
909
{
1359
 
        EDataCalPrivate *priv;
1360
 
        CORBA_Environment ev;
1361
 
 
1362
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1363
 
 
1364
 
        priv = cal->priv;
1365
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1366
 
 
1367
 
        CORBA_exception_init (&ev);
1368
 
        GNOME_Evolution_Calendar_CalListener_notifyDefaultTimezoneSet (priv->listener, status, &ev);
1369
 
 
1370
 
        if (BONOBO_EX (&ev))
1371
 
                g_warning (G_STRLOC ": could not notify the listener of default timezone set");
1372
 
 
1373
 
        CORBA_exception_free (&ev);
 
910
        DBusGMethodInvocation *method = context;
 
911
        if (status != Success)
 
912
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Could not set default calendar time zone")));
 
913
        else
 
914
                dbus_g_method_return (method);
1374
915
}
1375
916
 
1376
917
/**
1384
925
 * Notifies listeners of the completion of the get_changes method call.
1385
926
 */
1386
927
void
1387
 
e_data_cal_notify_changes (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status,
 
928
e_data_cal_notify_changes (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status,
1388
929
                           GList *adds, GList *modifies, GList *deletes)
1389
930
{
1390
 
        EDataCalPrivate *priv;
1391
 
        CORBA_Environment ev;
1392
 
        GNOME_Evolution_Calendar_CalObjChangeSeq seq;
1393
 
        GList *l;
1394
 
        gint n, i;
1395
 
 
1396
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1397
 
 
1398
 
        priv = cal->priv;
1399
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1400
 
 
1401
 
        n = g_list_length (adds) + g_list_length (modifies) + g_list_length (deletes);
1402
 
        seq._maximum = n;
1403
 
        seq._length = n;
1404
 
        seq._buffer = CORBA_sequence_GNOME_Evolution_Calendar_CalObjChange_allocbuf (n);
1405
 
 
1406
 
        i = 0;
1407
 
        for (l = adds; l; i++, l = l->next) {
1408
 
                GNOME_Evolution_Calendar_CalObjChange *change = &seq._buffer[i];
1409
 
 
1410
 
                change->calobj = CORBA_string_dup (l->data);
1411
 
                change->type = GNOME_Evolution_Calendar_ADDED;
1412
 
        }
1413
 
 
1414
 
        for (l = modifies; l; i++, l = l->next) {
1415
 
                GNOME_Evolution_Calendar_CalObjChange *change = &seq._buffer[i];
1416
 
 
1417
 
                change->calobj = CORBA_string_dup (l->data);
1418
 
                change->type = GNOME_Evolution_Calendar_MODIFIED;
1419
 
        }
1420
 
 
1421
 
        for (l = deletes; l; i++, l = l->next) {
1422
 
                GNOME_Evolution_Calendar_CalObjChange *change = &seq._buffer[i];
1423
 
 
1424
 
                change->calobj = CORBA_string_dup (l->data);
1425
 
                change->type = GNOME_Evolution_Calendar_DELETED;
1426
 
        }
1427
 
 
1428
 
        CORBA_exception_init (&ev);
1429
 
        GNOME_Evolution_Calendar_CalListener_notifyChanges (priv->listener, status, &seq, &ev);
1430
 
 
1431
 
        CORBA_free (seq._buffer);
1432
 
 
1433
 
        if (BONOBO_EX (&ev))
1434
 
                g_warning (G_STRLOC ": could not notify the listener of default timezone set");
1435
 
 
1436
 
        CORBA_exception_free (&ev);
 
931
        DBusGMethodInvocation *method = context;
 
932
        if (status != Success) {
 
933
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar changes")));
 
934
        } else {
 
935
                gchar **additions, **modifications, **removals;
 
936
                GList *l;
 
937
                gint i;
 
938
 
 
939
                additions = NULL;
 
940
                if (adds) {
 
941
                        additions = g_new0 (gchar *, g_list_length (adds) + 1);
 
942
                        if (additions)
 
943
                                for (i = 0, l = adds; l; i++, l = l->next)
 
944
                                        additions[i] = g_strdup (l->data);
 
945
                }
 
946
 
 
947
                modifications = NULL;
 
948
                if (modifies) {
 
949
                        modifications = g_new0 (gchar *, g_list_length (modifies) + 1);
 
950
                        if (modifications)
 
951
                                for (i = 0, l = modifies; l; i++, l = l->next)
 
952
                                        modifications[i] = g_strdup (l->data);
 
953
                }
 
954
 
 
955
                removals = NULL;
 
956
                if (deletes) {
 
957
                        removals = g_new0 (gchar *, g_list_length (deletes) + 1);
 
958
                        if (removals)
 
959
                                for (i = 0, l = deletes; l; i++, l = l->next)
 
960
                                        removals[i] = g_strdup (l->data);
 
961
                }
 
962
 
 
963
                dbus_g_method_return (method, additions, modifications, removals);
 
964
                if (additions) g_strfreev (additions);
 
965
                if (modifications) g_strfreev (modifications);
 
966
                if (removals) g_strfreev (removals);
 
967
        }
1437
968
}
1438
969
 
1439
970
/**
1445
976
 * Notifies listeners of the completion of the get_free_busy method call.
1446
977
 */
1447
978
void
1448
 
e_data_cal_notify_free_busy (EDataCal *cal, GNOME_Evolution_Calendar_CallStatus status, GList *freebusy)
 
979
e_data_cal_notify_free_busy (EDataCal *cal, EServerMethodContext context, EDataCalCallStatus status, GList *freebusy)
1449
980
{
1450
 
        EDataCalPrivate *priv;
1451
 
        CORBA_Environment ev;
1452
 
        GNOME_Evolution_Calendar_CalObjSeq seq;
1453
 
        GList *l;
1454
 
        gint n, i;
1455
 
 
1456
 
        g_return_if_fail (E_IS_DATA_CAL (cal));
1457
 
 
1458
 
        priv = cal->priv;
1459
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1460
 
 
1461
 
        n = g_list_length (freebusy);
1462
 
        seq._maximum = n;
1463
 
        seq._length = n;
1464
 
        seq._buffer = CORBA_sequence_GNOME_Evolution_Calendar_CalObj_allocbuf (n);
1465
 
 
1466
 
        for (i = 0, l = freebusy; l; i++, l = l->next)
1467
 
                seq._buffer[i] = CORBA_string_dup (l->data);
1468
 
 
1469
 
        CORBA_exception_init (&ev);
1470
 
        GNOME_Evolution_Calendar_CalListener_notifyFreeBusy (priv->listener, status, &seq, &ev);
1471
 
 
1472
 
        CORBA_free (seq._buffer);
1473
 
 
1474
 
        if (BONOBO_EX (&ev))
1475
 
                g_warning (G_STRLOC ": could not notify the listener of freebusy");
1476
 
 
1477
 
        CORBA_exception_free (&ev);
 
981
        DBusGMethodInvocation *method = context;
 
982
        if (status != Success) {
 
983
                dbus_g_method_return_error (method, g_error_new (E_DATA_CAL_ERROR, status, _("Cannot retrieve calendar free/busy list")));
 
984
        } else {
 
985
                gchar **seq;
 
986
                GList *l;
 
987
                gint i;
 
988
 
 
989
                seq = g_new0 (gchar *, g_list_length (freebusy) + 1);
 
990
                for (i = 0, l = freebusy; l; i++, l = l->next) {
 
991
                        seq[i] = g_strdup (l->data);
 
992
                }
 
993
 
 
994
                dbus_g_method_return (method, seq);
 
995
                g_strfreev (seq);
 
996
        }
1478
997
}
1479
998
 
1480
999
/**
1487
1006
 **/
1488
1007
void
1489
1008
e_data_cal_notify_mode (EDataCal *cal,
1490
 
                        GNOME_Evolution_Calendar_CalListener_SetModeStatus status,
1491
 
                        GNOME_Evolution_Calendar_CalMode mode)
 
1009
                        EDataCalViewListenerSetModeStatus status,
 
1010
                        EDataCalMode mode)
1492
1011
{
1493
 
        EDataCalPrivate *priv;
1494
 
        CORBA_Environment ev;
1495
 
 
1496
1012
        g_return_if_fail (cal != NULL);
1497
1013
        g_return_if_fail (E_IS_DATA_CAL (cal));
1498
1014
 
1499
 
        priv = cal->priv;
1500
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1501
 
 
1502
 
        CORBA_exception_init (&ev);
1503
 
        GNOME_Evolution_Calendar_CalListener_notifyCalSetMode (priv->listener, status, mode, &ev);
1504
 
 
1505
 
        if (BONOBO_EX (&ev))
1506
 
                g_message ("e_data_cal_notify_mode(): could not notify the listener "
1507
 
                           "about a mode change");
1508
 
 
1509
 
        CORBA_exception_free (&ev);
 
1015
        g_signal_emit (cal, signals[MODE], 0, mode);
1510
1016
}
1511
1017
 
1512
1018
/**
1518
1024
void
1519
1025
e_data_cal_notify_auth_required (EDataCal *cal)
1520
1026
{
1521
 
       EDataCalPrivate *priv;
1522
 
       CORBA_Environment ev;
1523
 
 
1524
 
       g_return_if_fail (cal != NULL);
1525
 
       g_return_if_fail (E_IS_DATA_CAL (cal));
1526
 
 
1527
 
       priv = cal->priv;
1528
 
       g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1529
 
 
1530
 
       CORBA_exception_init (&ev);
1531
 
       GNOME_Evolution_Calendar_CalListener_notifyAuthRequired (priv->listener,  &ev);
1532
 
       if (BONOBO_EX (&ev))
1533
 
                g_message ("e_data_cal_notify_auth_required: could not notify the listener "
1534
 
                           "about auth required");
1535
 
 
1536
 
        CORBA_exception_free (&ev);
 
1027
        g_return_if_fail (cal != NULL);
 
1028
        g_return_if_fail (E_IS_DATA_CAL (cal));
 
1029
 
 
1030
        g_signal_emit (cal, signals[AUTH_REQUIRED], 0);
1537
1031
}
1538
1032
 
1539
1033
/**
1546
1040
void
1547
1041
e_data_cal_notify_error (EDataCal *cal, const gchar *message)
1548
1042
{
1549
 
        EDataCalPrivate *priv;
1550
 
        CORBA_Environment ev;
1551
 
 
1552
1043
        g_return_if_fail (cal != NULL);
1553
1044
        g_return_if_fail (E_IS_DATA_CAL (cal));
1554
 
        g_return_if_fail (message != NULL);
1555
 
 
1556
 
        priv = cal->priv;
1557
 
        g_return_if_fail (priv->listener != CORBA_OBJECT_NIL);
1558
 
 
1559
 
        CORBA_exception_init (&ev);
1560
 
        GNOME_Evolution_Calendar_CalListener_notifyErrorOccurred (priv->listener, (gchar *) message, &ev);
1561
 
 
1562
 
        if (BONOBO_EX (&ev))
1563
 
                g_message ("e_data_cal_notify_remove(): could not notify the listener "
1564
 
                           "about a removed object");
1565
 
 
1566
 
        CORBA_exception_free (&ev);
 
1045
 
 
1046
        g_signal_emit (cal, signals[BACKEND_ERROR], 0, message);
1567
1047
}