diff options
Diffstat (limited to 'calendar/cal-client')
| -rw-r--r-- | calendar/cal-client/Makefile.am | 2 | ||||
| -rw-r--r-- | calendar/cal-client/cal-client-multi.c | 707 | ||||
| -rw-r--r-- | calendar/cal-client/cal-client-multi.h | 105 | ||||
| -rw-r--r-- | calendar/cal-client/cal-client.c | 86 | ||||
| -rw-r--r-- | calendar/cal-client/cal-client.h | 4 | ||||
| -rw-r--r-- | calendar/cal-client/client-test.c | 24 |
6 files changed, 889 insertions, 39 deletions
diff --git a/calendar/cal-client/Makefile.am b/calendar/cal-client/Makefile.am index e910aa9610..28bab236ae 100644 --- a/calendar/cal-client/Makefile.am +++ b/calendar/cal-client/Makefile.am @@ -38,6 +38,7 @@ libcal_clientincludedir = $(includedir)/evolution/cal-client libcal_client_la_SOURCES = \ $(CORBA_GENERATED) \ + cal-client-multi.c \ cal-client-types.c \ cal-client.c \ cal-listener.c \ @@ -48,6 +49,7 @@ libcal_client_la_SOURCES = \ libcal_clientinclude_HEADERS = \ $(CORBA_HEADERS_GENERATED) \ + cal-client-multi.h \ cal-client-types.h \ cal-client.h \ cal-query.h diff --git a/calendar/cal-client/cal-client-multi.c b/calendar/cal-client/cal-client-multi.c new file mode 100644 index 0000000000..c351d6cbd6 --- /dev/null +++ b/calendar/cal-client/cal-client-multi.c @@ -0,0 +1,707 @@ +/* Evolution calendar client + * + * Copyright (C) 2001 Ximian, Inc. + * + * Author: Rodrigo Moya <rodrigo@ximian.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include <gtk/gtksignal.h> +#include "cal-client-multi.h" + +/* Private part of the CalClientMulti structure */ +struct _CalClientMultiPrivate { + GHashTable *calendars; + GList *uris; +}; + +static void cal_client_multi_class_init (CalClientMultiClass *klass); +static void cal_client_multi_init (CalClientMulti *multi); +static void cal_client_multi_destroy (GtkObject *object); + +/* signal IDs */ +enum { + CAL_OPENED, + OBJ_UPDATED, + OBJ_REMOVED, + CATEGORIES_CHANGED, + FORGET_PASSWORD, + LAST_SIGNAL +}; + +static guint cal_multi_signals[LAST_SIGNAL]; +static GtkObjectClass *parent_class = NULL; + +/* + * Private functions + */ + +/** + * cal_client_multi_get_type + * + * Registers the #CalClientMulti class if necessary, and returns the type ID + * assigned to it. + * + * Returns: The type ID of the #CalClientMulti class + */ +GtkType +cal_client_multi_get_type (void) +{ + static GtkType type = 0; + + if (!type) { + static const GtkTypeInfo info = { + "CalClientMulti", + sizeof (CalClientMulti), + sizeof (CalClientMultiClass), + (GtkClassInitFunc) cal_client_multi_class_init, + (GtkObjectInitFunc) cal_client_multi_init, + NULL, + NULL, + (GtkClassInitFunc) NULL + }; + + type = gtk_type_unique (GTK_TYPE_OBJECT, &info); + } + + return type; +} + +/* class initialization function for the multi calendar client */ +static void +cal_client_multi_class_init (CalClientMultiClass *klass) +{ + GtkObjectClass *object_class = GTK_OBJECT_CLASS (klass); + + parent_class = gtk_type_class (GTK_TYPE_OBJECT); + + cal_multi_signals[CAL_OPENED] = + gtk_signal_new ("cal_opened", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalClientMultiClass, cal_opened), + gtk_marshal_NONE__POINTER_INT, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, GTK_TYPE_ENUM); + cal_multi_signals[OBJ_UPDATED] = + gtk_signal_new ("obj_updated", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalClientMultiClass, obj_updated), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, GTK_TYPE_STRING); + cal_multi_signals[OBJ_REMOVED] = + gtk_signal_new ("obj_removed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalClientMultiClass, obj_removed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, GTK_TYPE_STRING); + cal_multi_signals[CATEGORIES_CHANGED] = + gtk_signal_new ("categories_changed", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalClientMultiClass, categories_changed), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_POINTER, GTK_TYPE_POINTER); + cal_multi_signals[FORGET_PASSWORD] = + gtk_signal_new ("forget_password", + GTK_RUN_FIRST, + object_class->type, + GTK_SIGNAL_OFFSET (CalClientMultiClass, forget_password), + gtk_marshal_NONE__POINTER_POINTER, + GTK_TYPE_NONE, 2, + GTK_TYPE_STRING, GTK_TYPE_STRING); + + object_class->destroy = cal_client_multi_destroy; +} + +/* object initialization function for the multi calendar client */ +static void +cal_client_multi_init (CalClientMulti *multi) +{ + multi->priv = g_new0 (CalClientMultiPrivate, 1); + multi->priv->calendars = g_hash_table_new (g_str_hash, g_str_equal); + multi->priv->uris = NULL; +} + +static void +free_calendar (gpointer key, gpointer value, gpointer data) +{ + CalClientMulti *multi = (CalClientMulti *) data; + + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + multi->priv->uris = g_list_remove (multi->priv->uris, key); + + g_free (key); + gtk_object_unref (GTK_OBJECT (value)); +} + +/* destroy handler for the multi calendar client */ +static void +cal_client_multi_destroy (GtkObject *object) +{ + CalClientMulti *multi = (CalClientMulti *) object; + + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + /* free memory */ + g_hash_table_foreach (multi->priv->calendars, free_calendar, multi); + g_hash_table_destroy (multi->priv->calendars); + g_list_free (multi->priv->uris); + + g_free (multi->priv); + multi->priv = NULL; + + /* chain to parent class' destroy handler */ + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + +/** + * cal_client_multi_new + * + * Creates a new multi-calendar client. This allows you to merge several + * #CalClient objects into one entity, making it easier to manage + * multiple calendars. + * + * Returns: A newly-created multi-calendar client. + */ +CalClientMulti * +cal_client_multi_new (void) +{ + CalClientMulti *multi; + + multi = gtk_type_new (CAL_CLIENT_MULTI_TYPE); + return multi; +} + +/* CalClient's signal handlers */ +static void +client_cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer user_data) +{ + CalClientMulti *multi = (CalClientMulti *) user_data; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + gtk_signal_emit (GTK_OBJECT (multi), + cal_multi_signals[CAL_OPENED], + client, status); +} + +static void +client_obj_updated_cb (CalClient *client, const char *uid, gpointer user_data) +{ + CalClientMulti *multi = (CalClientMulti *) user_data; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + gtk_signal_emit (GTK_OBJECT (multi), + cal_multi_signals[OBJ_UPDATED], + client, uid); +} + +static void +client_obj_removed_cb (CalClient *client, const char *uid, gpointer user_data) +{ + CalClientMulti *multi = (CalClientMulti *) user_data; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + gtk_signal_emit (GTK_OBJECT (multi), + cal_multi_signals[OBJ_REMOVED], + client, uid); +} + +static void +client_categories_changed_cb (CalClient *client, GPtrArray *categories, gpointer user_data) +{ + CalClientMulti *multi = (CalClientMulti *) user_data; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + gtk_signal_emit (GTK_OBJECT (multi), + cal_multi_signals[CATEGORIES_CHANGED], + client, categories); +} + +static void +client_forget_password_cb (CalClient *client, const char *key, gpointer user_data) +{ + CalClientMulti *multi = (CalClientMulti *) user_data; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + gtk_signal_emit (GTK_OBJECT (multi), + cal_multi_signals[FORGET_PASSWORD], + client, key); +} +/** + * cal_client_multi_add_client + * @multi: A #CalClientMulti object. + * @client: The #CalClient object to be added. + * + * Aggregates the given #CalClient to a #CalClientMulti object, + * thus adding it to the list of managed calendars. + */ +void +cal_client_multi_add_client (CalClientMulti *multi, CalClient *client) +{ + char *uri; + CalClient *old_client; + + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + g_return_if_fail (IS_CAL_CLIENT (client)); + + uri = g_strdup (cal_client_get_uri (client)); + old_client = g_hash_table_lookup (multi->priv->calendars, uri); + if (old_client) { + g_free (uri); + return; + } + + gtk_object_ref (GTK_OBJECT (client)); + multi->priv->uris = g_list_append (multi->priv->uris, uri); + g_hash_table_insert (multi->priv->calendars, uri, client); + + /* set up CalClient's signal handlers */ + gtk_signal_disconnect_by_data (GTK_OBJECT (client), multi); + gtk_signal_connect (GTK_OBJECT (client), + "cal_opened", + GTK_SIGNAL_FUNC (client_cal_opened_cb), + multi); + gtk_signal_connect (GTK_OBJECT (client), + "obj_updated", + GTK_SIGNAL_FUNC (client_obj_updated_cb), + multi); + gtk_signal_connect (GTK_OBJECT (client), + "obj_removed", + GTK_SIGNAL_FUNC (client_obj_removed_cb), + multi); + gtk_signal_connect (GTK_OBJECT (client), + "categories_changed", + GTK_SIGNAL_FUNC (client_categories_changed_cb), + multi); + gtk_signal_connect (GTK_OBJECT (client), + "forget_password", + GTK_SIGNAL_FUNC (client_forget_password_cb), + multi); +} + +typedef struct { + CalClientAuthFunc func; + gpointer user_data; +} AuthFuncData; + +static void +set_auth_func (gpointer key, gpointer value, gpointer user_data) +{ + AuthFuncData *cb_data = (AuthFuncData *) user_data; + CalClient *client = (CalClient *) value; + + g_return_if_fail (IS_CAL_CLIENT (client)); + g_return_if_fail (cb_data != NULL); + + cal_client_set_auth_func (client, cb_data->func, cb_data->user_data); +} + +/** + * cal_client_multi_set_auth_func + * @multi: A #CalClientMulti object. + * @func: The authentication function. + * @user_data: Data to be passed to the authentication function. + * + * Sets the authentication function for all the clients in the + * given #CalClientMulti. + */ +void +cal_client_multi_set_auth_func (CalClientMulti *multi, + CalClientAuthFunc func, + gpointer user_data) +{ + AuthFuncData *cb_data; + + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + cb_data = g_new0 (AuthFuncData, 1); + cb_data->func = func; + cb_data->user_data = user_data; + g_hash_table_foreach (multi->priv->calendars, set_auth_func, cb_data); + + g_free (cb_data); +} + +/** + * cal_client_multi_open_calendar + * @multi: A #CalClientMulti object. + * @str_uri: The URI of the calendar to be open + * @only_if_exists: + * + * Open a new calendar in the given #CalClientMulti object. + * + * Returns: a pointer to the new #CalClient + */ +CalClient * +cal_client_multi_open_calendar (CalClientMulti *multi, + const char *str_uri, + gboolean only_if_exists) +{ + CalClient *client; + gboolean result; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), FALSE); + + client = cal_client_new (); + + result = cal_client_open_calendar (client, str_uri, only_if_exists); + if (result) { + cal_client_multi_add_client (multi, client); + gtk_object_unref (GTK_OBJECT (client)); + return client; + } + + gtk_object_unref (GTK_OBJECT (client)); + + return NULL; +} + +/** + * cal_client_multi_get_client_for_uri + * @multi: A #CalClientMulti object. + * @uri: The URI for the client. + * + * Returns the #CalClient object associated with the given + * @uri for the given #CalClientMulti object. + * + * Returns: a pointer to the client or NULL if no client is + * associated with that URI. + */ +CalClient * +cal_client_multi_get_client_for_uri (CalClientMulti *multi, const char *uri) +{ + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + g_return_val_if_fail (uri != NULL, NULL); + + return g_hash_table_lookup (multi->priv->calendars, uri); +} + +/** + * cal_client_multi_get_n_objects + * @multi: A #CalClientMulti object. + * @type: Type for objects + * + * Get the count of objects of the given type(s) for a #CalClientMulti + * object. + * + * Returns: The count of objects of the given type(s). + */ +int +cal_client_multi_get_n_objects (CalClientMulti *multi, + CalObjType type) +{ + CalClient *client; + GList *l; + int count = 0; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), -1); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) + count += cal_client_get_n_objects (client, type); + } + + return count; +} + +/** + * cal_client_multi_get_object + */ +CalClientGetStatus +cal_client_multi_get_object (CalClientMulti *multi, + const char *uid, + CalComponent **comp) +{ + CalClient *client; + GList *l; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), CAL_CLIENT_GET_NOT_FOUND); + g_return_val_if_fail (uid != NULL, CAL_CLIENT_GET_NOT_FOUND); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + CalClientGetStatus status; + + status = cal_client_get_object (client, uid, comp); + if (status == CAL_CLIENT_GET_SUCCESS) + return status; + } + } + + return CAL_CLIENT_GET_NOT_FOUND; +} + +/** + * cal_client_multi_get_timezone + * @multi: A #CalClientMulti object. + * @tzid: ID for the timezone to be retrieved. + * @zone: A pointer to where the icaltimezone object will be copied. + */ +CalClientGetStatus +cal_client_multi_get_timezone (CalClientMulti *multi, + const char *tzid, + icaltimezone **zone) +{ + CalClient *client; + GList *l; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), CAL_CLIENT_GET_NOT_FOUND); + g_return_val_if_fail (tzid != NULL, CAL_CLIENT_GET_NOT_FOUND); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + CalClientGetStatus status; + + status = cal_client_get_timezone (client, tzid, zone); + if (status == CAL_CLIENT_GET_SUCCESS) + return status; + } + } + + return CAL_CLIENT_GET_NOT_FOUND; +} + +/** + * cal_client_multi_get_uids + * @multi: A #CalClientMulti object. + * @type: Type of objects whose IDs will be returned. + * + * Returns a list of UIDs for all the objects of the given + * type(s) that are in the calendars managed by a + * #CalClientMulti object + * + * Returns: a GList of UIDs. + */ +GList * +cal_client_multi_get_uids (CalClientMulti *multi, CalObjType type) +{ + CalClient *client; + GList *l; + GList *result = NULL; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + GList *tmp; + + tmp = cal_client_get_uids (client, type); + if (tmp) + result = g_list_concat (result, tmp); + } + } + + return result; +} + +/** + * cal_client_multi_get_changes + * @multi: A #CalClientMulti object. + * @type: Object type. + * @change_id: Change ID. + * + * Returns a list of changes for the given #CalClientMulti + * object. + */ +GList * +cal_client_multi_get_changes (CalClientMulti *multi, + CalObjType type, + const char *change_id) +{ + CalClient *client; + GList *l; + GList *result = NULL; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + GList *tmp; + + tmp = cal_client_get_changes (client, type, change_id); + if (tmp) + result = g_list_concat (result, tmp); + } + } + + return result; +} + +/** + * cal_client_multi_get_objects_in_range + * @multi: A #CalClientMulti object. + * @type: Type for objects. + * @start: Start time. + * @end: End time. + * + * Retrieves a list of all calendar components that are + * scheduled within the given time range. The information is + * retrieved from all the calendars being managed by the + * given #CalClientMulti object. + * + * Returns: A list of UID strings. This should be freed using the + * #cal_obj_uid_list_free() function. + **/ +GList * +cal_client_multi_get_objects_in_range (CalClientMulti *multi, + CalObjType type, + time_t start, + time_t end) +{ + CalClient *client; + GList *l; + GList *result = NULL; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + GList *tmp; + + tmp = cal_client_get_objects_in_range (client, type, start, end); + if (tmp) + result = g_list_concat (result, tmp); + } + } + + return result; +} + +/** + * cal_client_multi_get_free_busy + * @multi: A #CalClientMulti object. + * @users: List of users to retrieve F/B information for. + * @start: Start time. + * @end: End time. + * + * Retrieves Free/Busy information for the given users in all + * the calendars being managed by the given #CalClient multi + * object. + * + * Returns: A GList of VFREEBUSY CalComponents + */ +GList * +cal_client_multi_get_free_busy (CalClientMulti *multi, + GList *users, + time_t start, + time_t end) +{ + CalClient *client; + GList *l; + GList *result = NULL; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + GList *tmp; + + tmp = cal_client_get_free_busy (client, users, start, end); + if (tmp) + result = g_list_concat (result, tmp); + } + } + + return result; +} + +/** + * cal_client_multi_generate_instances + */ +void +cal_client_multi_generate_instances (CalClientMulti *multi, + CalObjType type, + time_t start, + time_t end, + CalRecurInstanceFn cb, + gpointer cb_data) +{ + CalClient *client; + GList *l; + + g_return_if_fail (IS_CAL_CLIENT_MULTI (multi)); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + cal_client_generate_instances ( + client, type, start, end, cb, cb_data); + } + } +} + +/** + * cal_client_multi_get_alarms_in_range + */ +GSList * +cal_client_multi_get_alarms_in_range (CalClientMulti *multi, time_t start, time_t end) +{ + CalClient *client; + GList *l; + GSList *result = NULL; + + g_return_val_if_fail (IS_CAL_CLIENT_MULTI (multi), NULL); + + for (l = multi->priv->uris; l; l = l->next) { + client = cal_client_multi_get_client_for_uri (multi, + (const char *) l->data); + if (IS_CAL_CLIENT (client)) { + GSList *tmp; + + tmp = cal_client_get_alarms_in_range (client, start, end); + if (tmp) + result = g_slist_concat (result, tmp); + } + } + + return result; +} diff --git a/calendar/cal-client/cal-client-multi.h b/calendar/cal-client/cal-client-multi.h new file mode 100644 index 0000000000..0b7eec40e4 --- /dev/null +++ b/calendar/cal-client/cal-client-multi.h @@ -0,0 +1,105 @@ +/* Evolution calendar client + * + * Copyright (C) 2001 Ximian, Inc. + * + * Author: Rodrigo Moya <rodrigo@ximian.com> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CAL_CLIENT_MULTI_H +#define CAL_CLIENT_MULTI_H + +#include <cal-client/cal-client.h> + +BEGIN_GNOME_DECLS + +#define CAL_CLIENT_MULTI_TYPE (cal_client_multi_get_type ()) +#define CAL_CLIENT_MULTI(obj) (GTK_CHECK_CAST ((obj), CAL_CLIENT_MULTI_TYPE, CalClientMulti)) +#define CAL_CLIENT_MULTI_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), CAL_CLIENT_MULTI_TYPE, CalClientMultiClass)) +#define IS_CAL_CLIENT_MULTI(obj) (GTK_CHECK_TYPE ((obj), CAL_CLIENT_MULTI_TYPE)) +#define IS_CAL_CLIENT_MULTI_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_CLIENT_MULTI_TYPE)) + +typedef struct _CalClientMulti CalClientMulti; +typedef struct _CalClientMultiClass CalClientMultiClass; +typedef struct _CalClientMultiPrivate CalClientMultiPrivate; + +struct _CalClientMulti { + GtkObject object; + + /* Private data */ + CalClientMultiPrivate *priv; +}; + +struct _CalClientMultiClass { + GtkObjectClass parent_class; + + /* notification signals */ + void (* cal_opened) (CalClientMulti *multi, CalClient *client, CalClientOpenStatus status); + + void (* obj_updated) (CalClientMulti *multi, CalClient *client, const char *uid); + void (* obj_removed) (CalClientMulti *multi, CalClient *client, const char *uid); + + void (* categories_changed) (CalClientMulti *multi, CalClient *client, GPtrArray *categories); + + void (* forget_password) (CalClientMulti *multi, CalClient *client, const char *key); +}; + +GtkType cal_client_multi_get_type (void); + +CalClientMulti *cal_client_multi_new (void); + +void cal_client_multi_add_client (CalClientMulti *multi, CalClient *client); +void cal_client_multi_set_auth_func (CalClientMulti *multi, + CalClientAuthFunc func, + gpointer user_data); + +CalClient *cal_client_multi_open_calendar (CalClientMulti *multi, + const char *str_uri, + gboolean only_if_exists); +CalClient *cal_client_multi_get_client_for_uri (CalClientMulti *multi, + const char *uri); + +int cal_client_multi_get_n_objects (CalClientMulti *multi, CalObjType type); +CalClientGetStatus cal_client_multi_get_object (CalClientMulti *multi, + const char *uid, + CalComponent **comp); +CalClientGetStatus cal_client_multi_get_timezone (CalClientMulti *multi, + const char *tzid, + icaltimezone **zone); +GList *cal_client_multi_get_uids (CalClientMulti *multi, CalObjType type); +GList *cal_client_multi_get_changes (CalClientMulti *multi, + CalObjType type, + const char *change_id); +GList *cal_client_multi_get_objects_in_range (CalClientMulti *multi, + CalObjType type, + time_t start, + time_t end); +GList *cal_client_multi_get_free_busy (CalClientMulti *multi, + GList *users, + time_t start, + time_t end); +void cal_client_multi_generate_instances (CalClientMulti *multi, + CalObjType type, + time_t start, + time_t end, + CalRecurInstanceFn cb, + gpointer cb_data); +GSList *cal_client_multi_get_alarms_in_range (CalClientMulti *multi, + time_t start, time_t end); + +END_GNOME_DECLS + +#endif diff --git a/calendar/cal-client/cal-client.c b/calendar/cal-client/cal-client.c index f0519057d6..e0a37159f5 100644 --- a/calendar/cal-client/cal-client.c +++ b/calendar/cal-client/cal-client.c @@ -1224,56 +1224,86 @@ cal_client_get_objects_in_range (CalClient *client, CalObjType type, time_t star /** * cal_client_get_free_busy * @client:: A calendar client. + * @users: List of users to retrieve free/busy information for. * @start: Start time for query. * @end: End time for query. * - * Gets free/busy information from the calendar server + * Gets free/busy information from the calendar server. + * + * Returns: a GList of VFREEBUSY CalComponents */ -CalClientGetStatus -cal_client_get_free_busy (CalClient *client, time_t start, time_t end, CalComponent **comp) +GList * +cal_client_get_free_busy (CalClient *client, GList *users, + time_t start, time_t end) { CalClientPrivate *priv; CORBA_Environment ev; - CORBA_char *calobj; - icalcomponent *icalcomp; + GNOME_Evolution_Calendar_UserList *corba_list; + GNOME_Evolution_Calendar_CalObjSeq *calobj_list; + GList *l; + GList *comp_list = NULL; + int len, i; - g_return_val_if_fail (client != NULL, CAL_CLIENT_GET_NOT_FOUND); - g_return_val_if_fail (IS_CAL_CLIENT (client), CAL_CLIENT_GET_NOT_FOUND); + g_return_val_if_fail (client != NULL, NULL); + g_return_val_if_fail (IS_CAL_CLIENT (client), NULL); priv = client->priv; - g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, CAL_CLIENT_GET_NOT_FOUND); + g_return_val_if_fail (priv->load_state == CAL_CLIENT_LOAD_LOADED, NULL); - g_return_val_if_fail (start != -1 && end != -1, CAL_CLIENT_GET_NOT_FOUND); - g_return_val_if_fail (start <= end, CAL_CLIENT_GET_NOT_FOUND); - g_return_val_if_fail (comp != NULL, CAL_CLIENT_GET_NOT_FOUND); + g_return_val_if_fail (start != -1 && end != -1, NULL); + g_return_val_if_fail (start <= end, NULL); - *comp = NULL; + /* create the CORBA user list to be passed to the backend */ + len = g_list_length (users); + corba_list = GNOME_Evolution_Calendar_UserList__alloc (); + CORBA_sequence_set_release (corba_list, TRUE); + corba_list->_length = len; + corba_list->_buffer = CORBA_sequence_GNOME_Evolution_Calendar_User_allocbuf (len); + + for (l = g_list_first (users), i = 0; l; l = l->next, i++) + corba_list->_buffer[i] = CORBA_string_dup ((CORBA_char *) l->data); + + /* call the method on the backend */ CORBA_exception_init (&ev); - calobj = GNOME_Evolution_Calendar_Cal_getFreeBusy (priv->cal, start, end, &ev); - if (ev._major != CORBA_NO_EXCEPTION) { + calobj_list = GNOME_Evolution_Calendar_Cal_getFreeBusy (priv->cal, corba_list, + start, end, &ev); + CORBA_free (corba_list); + if (ev._major != CORBA_NO_EXCEPTION || !calobj_list) { g_message ("cal_client_get_free_busy(): could not get the objects"); CORBA_exception_free (&ev); - return CAL_CLIENT_GET_NOT_FOUND; + return NULL; } - CORBA_exception_free (&ev); - icalcomp = icalparser_parse_string (calobj); - CORBA_free (calobj); - if (!icalcomp) { - return CAL_CLIENT_GET_SYNTAX_ERROR; - } + for (i = 0; i < calobj_list->_length; i++) { + CalComponent *comp; + icalcomponent *icalcomp; + icalcomponent_kind kind; - *comp = cal_component_new (); - if (!cal_component_set_icalcomponent (*comp, icalcomp)) { - icalcomponent_free (icalcomp); - gtk_object_unref (GTK_OBJECT (*comp)); - *comp = NULL; - return CAL_CLIENT_GET_SYNTAX_ERROR; + icalcomp = icalparser_parse_string (calobj_list->_buffer[i]); + if (!icalcomp) + continue; + + kind = icalcomponent_isa (icalcomp); + if (kind == ICAL_VFREEBUSY_COMPONENT) { + comp = cal_component_new (); + if (!cal_component_set_icalcomponent (comp, icalcomp)) { + icalcomponent_free (icalcomp); + gtk_object_unref (GTK_OBJECT (comp)); + continue; + } + + comp_list = g_list_append (comp_list, comp); + } + else + icalcomponent_free (icalcomp); } - return CAL_CLIENT_GET_SUCCESS; + CORBA_exception_free (&ev); + CORBA_free (calobj_list); + + return comp_list; } /* Callback used when an object is updated and we must update the copy we have */ diff --git a/calendar/cal-client/cal-client.h b/calendar/cal-client/cal-client.h index a5facbd1c6..315f05e054 100644 --- a/calendar/cal-client/cal-client.h +++ b/calendar/cal-client/cal-client.h @@ -122,8 +122,8 @@ GList *cal_client_get_changes (CalClient *client, CalObjType type, const char *c GList *cal_client_get_objects_in_range (CalClient *client, CalObjType type, time_t start, time_t end); -CalClientGetStatus cal_client_get_free_busy (CalClient *client, time_t start, time_t end, - CalComponent **comp); +GList *cal_client_get_free_busy (CalClient *client, GList *users, + time_t start, time_t end); void cal_client_generate_instances (CalClient *client, CalObjType type, time_t start, time_t end, diff --git a/calendar/cal-client/client-test.c b/calendar/cal-client/client-test.c index f9c53bb74c..42d933f881 100644 --- a/calendar/cal-client/client-test.c +++ b/calendar/cal-client/client-test.c @@ -134,15 +134,22 @@ cal_opened_cb (CalClient *client, CalClientOpenStatus status, gpointer data) "unknown status value")); if (status == CAL_CLIENT_OPEN_SUCCESS) { - CalComponent *comp; + GList *comp_list; /* get free/busy information */ - cal_client_get_free_busy (client, 0, time (NULL), &comp); - if (IS_CAL_COMPONENT (comp)) { - char *comp_str = cal_component_get_as_string (comp); - gtk_object_unref (GTK_OBJECT (comp)); - cl_printf (client, "Free/Busy -> %s\n", comp_str); - g_free (comp_str); + comp_list = cal_client_get_free_busy (client, NULL, 0, time (NULL)); + if (comp_list) { + GList *l; + + for (l = comp_list; l; l = l->next) { + char *comp_str; + + comp_str = cal_component_get_as_string (CAL_COMPONENT (l->data)); + gtk_object_unref (GTK_OBJECT (l->data)); + cl_printf (client, "Free/Busy -> %s\n", comp_str); + g_free (comp_str); + } + g_list_free (comp_list); } g_idle_add (list_uids, client); @@ -225,9 +232,8 @@ main (int argc, char **argv) dir = g_strdup_printf ("%s/evolution/local/Calendar/calendar.ics", g_get_home_dir ()); create_client (&client1, dir, FALSE); - create_client (&client2, "/cvs/evolution/calendar/cal-client/test.ics", TRUE); - g_free (dir); + create_client (&client2, "/cvs/evolution/calendar/cal-client/test.ics", TRUE); bonobo_main (); return 0; |