From 642d32d63f226cd1ba049a9d979132e1a1cef94d Mon Sep 17 00:00:00 2001 From: Damon Chaplin Date: Tue, 3 Jul 2001 04:21:37 +0000 Subject: cal-client/cal-client.[hc] cal-util/cal-component.c 2001-07-03 Damon Chaplin * cal-client/cal-client.[hc] * cal-util/cal-component.c * cal-util/cal-recur.[hc] * cal-util/test-recur.c * cal-util/timeutil.c * gui/calendar-config.c * gui/calendar-model.[hc] * gui/comp-util.[hc] * gui/e-calendar-table.c * gui/e-day-view-main-item.c * gui/e-day-view-top-item.c * gui/e-day-view.[hc] * gui/e-itip-control.c * gui/e-timezone-entry.[hc] * gui/e-week-view.[hc] * gui/gnome-cal.[hc] * gui/goto.c * gui/tag-calendar.[hc] * gui/dialogs/cal-prefs-dialog.c * gui/dialogs/comp-editor-page.[hc] * gui/dialogs/comp-editor-util.[hc] * gui/dialogs/comp-editor.c * gui/dialogs/e-timezone-dialog.[hc] * gui/dialogs/event-page.c * gui/dialogs/meeting-page.c * gui/dialogs/recurrence-page.c * gui/dialogs/task-details-page.c * gui/dialogs/task-details-page.glade * gui/dialogs/task-page.c * idl/evolution-calendar.idl * pcs/cal-backend-file.c * pcs/cal-backend.c * pcs/cal-backend.h * pcs/cal.c * pcs/query.c: timezone changes everywhere. There's still quite a few things to update, and its not working well at present. svn path=/trunk/; revision=10729 --- calendar/cal-client/cal-client.c | 254 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 252 insertions(+), 2 deletions(-) (limited to 'calendar/cal-client/cal-client.c') diff --git a/calendar/cal-client/cal-client.c b/calendar/cal-client/cal-client.c index a4a0851975..6bef9508b3 100644 --- a/calendar/cal-client/cal-client.c +++ b/calendar/cal-client/cal-client.c @@ -58,6 +58,10 @@ struct _CalClientPrivate { /* The WombatClient */ WombatClient *w_client; + + /* A cache of timezones retrieved from the server, to avoid getting + them repeatedly for each get_object() call. */ + GHashTable *timezones; }; @@ -180,6 +184,7 @@ cal_client_init (CalClient *client) priv->load_state = CAL_CLIENT_LOAD_NOT_LOADED; priv->uri = NULL; priv->factory = CORBA_OBJECT_NIL; + priv->timezones = g_hash_table_new (g_str_hash, g_str_equal); /* create the WombatClient */ priv->w_client = wombat_client_new ( @@ -291,6 +296,14 @@ destroy_cal (CalClient *client) } +static void +free_timezone (gpointer key, gpointer value, gpointer data) +{ + /* Note that the key comes from within the icaltimezone value, so we + don't free that. */ + icaltimezone_free (value); +} + /* Destroy handler for the calendar client */ static void cal_client_destroy (GtkObject *object) @@ -316,6 +329,10 @@ cal_client_destroy (GtkObject *object) priv->uri = NULL; } + g_hash_table_foreach (priv->timezones, free_timezone, NULL); + g_hash_table_destroy (priv->timezones); + priv->timezones = NULL; + g_free (priv); client->priv = NULL; @@ -804,6 +821,109 @@ cal_client_get_object (CalClient *client, const char *uid, CalComponent **comp) return retval; } +CalClientGetStatus +cal_client_get_timezone (CalClient *client, + const char *tzid, + icaltimezone **zone) +{ + CalClientPrivate *priv; + CORBA_Environment ev; + GNOME_Evolution_Calendar_CalObj comp_str; + CalClientGetStatus retval; + icalcomponent *icalcomp; + icaltimezone *tmp_zone; + + 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); + + 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 (zone != NULL, CAL_CLIENT_GET_NOT_FOUND); + + /* If tzid is NULL or "" we return NULL, since it is a 'local time'. */ + if (!tzid || !tzid[0]) { + *zone = NULL; + return CAL_CLIENT_GET_SUCCESS; + } + + /* If it is UTC, we return the special UTC timezone. */ + if (!strcmp (tzid, "UTC")) { + *zone = icaltimezone_get_utc_timezone (); + return CAL_CLIENT_GET_SUCCESS; + } + + /* See if we already have it in the cache. */ + tmp_zone = g_hash_table_lookup (priv->timezones, tzid); + if (tmp_zone) { + *zone = tmp_zone; + return CAL_CLIENT_GET_SUCCESS; + } + + retval = CAL_CLIENT_GET_NOT_FOUND; + *zone = NULL; + + /* We don't already have it, so we try to get it from the server. */ + CORBA_exception_init (&ev); + comp_str = GNOME_Evolution_Calendar_Cal_getTimezoneObject (priv->cal, (char *) tzid, &ev); + + if (ev._major == CORBA_USER_EXCEPTION + && strcmp (CORBA_exception_id (&ev), ex_GNOME_Evolution_Calendar_Cal_NotFound) == 0) + goto out; + else if (ev._major != CORBA_NO_EXCEPTION) { + g_message ("cal_client_get_timezone(): could not get the object"); + goto out; + } + + icalcomp = icalparser_parse_string (comp_str); + CORBA_free (comp_str); + + if (!icalcomp) { + retval = CAL_CLIENT_GET_SYNTAX_ERROR; + goto out; + } + + tmp_zone = icaltimezone_new (); + if (!tmp_zone) { + /* FIXME: Needs better error code - out of memory. Or just + abort like GTK+ does? */ + retval = CAL_CLIENT_GET_NOT_FOUND; + goto out; + } + + if (!icaltimezone_set_component (tmp_zone, icalcomp)) { + retval = CAL_CLIENT_GET_SYNTAX_ERROR; + goto out; + } + + /* Now add it to the cache, to avoid the server call in future. */ + g_hash_table_insert (priv->timezones, icaltimezone_get_tzid (tmp_zone), + tmp_zone); + + *zone = tmp_zone; + retval = CAL_CLIENT_GET_SUCCESS; + + out: + + CORBA_exception_free (&ev); + return retval; +} + +/* Resolves TZIDs for the recurrence generator. */ +icaltimezone* +cal_client_resolve_tzid (const char *tzid, CalClient *client) +{ + icaltimezone *zone = NULL; + CalClientGetStatus status; + + /* FIXME: Handle errors. */ + status = cal_client_get_timezone (client, tzid, &zone); + + return zone; +} + + /* Builds an UID list out of a CORBA UID sequence */ static GList * build_uid_list (GNOME_Evolution_Calendar_CalObjUIDSeq *seq) @@ -1310,7 +1430,7 @@ cal_client_generate_instances (CalClient *client, CalObjType type, CalComponent *comp; comp = l->data; - cal_recur_generate_instances (comp, start, end, add_instance, &instances); + cal_recur_generate_instances (comp, start, end, add_instance, &instances, (CalRecurResolveTimezoneFn) cal_client_resolve_tzid, client); gtk_object_unref (GTK_OBJECT (comp)); } @@ -1570,6 +1690,135 @@ cal_client_get_alarms_for_object (CalClient *client, const char *uid, return retval; } +typedef struct _ForeachTZIDCallbackData ForeachTZIDCallbackData; +struct _ForeachTZIDCallbackData { + CalClient *client; + GHashTable *timezone_hash; +}; + +/* This adds the VTIMEZONE given by the TZID parameter to the GHashTable in + data. */ +static void +foreach_tzid_callback (icalparameter *param, void *cbdata) +{ + ForeachTZIDCallbackData *data = cbdata; + CalClientPrivate *priv; + const char *tzid; + icaltimezone *zone; + icalcomponent *vtimezone_comp; + char *vtimezone_as_string; + + priv = data->client->priv; + + /* Get the TZID string from the parameter. */ + tzid = icalparameter_get_tzid (param); + if (!tzid) + return; + + /* Check if it is in our cache. If it is, it must already be on the + server so return. */ + if (g_hash_table_lookup (priv->timezones, tzid)) + return; + + /* Check if we've already added it to the GHashTable. */ + if (g_hash_table_lookup (data->timezone_hash, tzid)) + return; + + /* Check if it is a builtin timezone. If it isn't, return. */ + zone = icaltimezone_get_builtin_timezone_from_tzid (tzid); + if (!zone) + return; + + /* Convert it to a string and add it to the hash. */ + vtimezone_comp = icaltimezone_get_component (zone); + if (!vtimezone_comp) + return; + + vtimezone_as_string = icalcomponent_as_ical_string (vtimezone_comp); + + g_hash_table_insert (data->timezone_hash, (char*) tzid, + g_strdup (vtimezone_as_string)); +} + +/* This appends the value string to the GString given in data. */ +static void +append_timezone_string (gpointer key, gpointer value, gpointer data) +{ + GString *vcal_string = data; + + g_string_append (vcal_string, value); + g_free (value); +} + + +/* This converts the VEVENT/VTODO to a string. It checks if we need to send + any builtin timezones to the server along with the object. + To do that we check every TZID in the component to see if it is a builtin + timezone. If it is, we see if it it in our cache. If it is in our cache, + then we know the server already has it and we don't need to send it. + If it isn't in our cache, then we need to send it to the server, and we + can add it to the cache as well. If we need to send any timezones to the + server, then we have to create a complete VCALENDAR object, otherwise + we can just send a single VEVENT/VTODO as before. */ +static char* +cal_client_get_component_as_string (CalClient *client, + CalComponent *comp) +{ + GHashTable *timezone_hash; + GString *vcal_string; + int initial_vcal_string_len; + ForeachTZIDCallbackData cbdata; + char *obj_string; + + CalClientPrivate *priv; + + priv = client->priv; + + timezone_hash = g_hash_table_new (g_str_hash, g_str_equal); + + /* Add any builtin timezones needed to the hash. We use a hash since + we only want to add each timezone once at most. */ + cbdata.client = client; + cbdata.timezone_hash = timezone_hash; + icalcomponent_foreach_tzid (cal_component_get_icalcomponent (comp), + foreach_tzid_callback, &cbdata); + + /* Create the start of a VCALENDAR, to add the VTIMEZONES to, + and remember its length so we know if any VTIMEZONEs get added. */ + vcal_string = g_string_new (NULL); + g_string_append (vcal_string, + "BEGIN:VCALENDAR\n" + "PRODID:-//Ximian//NONSGML Evolution Calendar//EN\n" + "VERSION:2.0\n"); + initial_vcal_string_len = vcal_string->len; + + /* Now concatenate all the timezone strings. This also frees the + timezone strings as it goes. */ + g_hash_table_foreach (timezone_hash, append_timezone_string, + vcal_string); + + /* Get the string for the VEVENT/VTODO. */ + obj_string = cal_component_get_as_string (comp); + + /* If there were any timezones to send, create a complete VCALENDAR, + else just send the VEVENT/VTODO string. */ + if (vcal_string->len == initial_vcal_string_len) { + g_string_free (vcal_string, TRUE); + } else { + g_string_append (vcal_string, obj_string); + g_string_append (vcal_string, "END:VCALENDAR\n"); + g_free (obj_string); + obj_string = vcal_string->str; + g_string_free (vcal_string, FALSE); + } + + g_hash_table_destroy (timezone_hash); + + fprintf (stderr, "Object String:\n=======\n%s======\n", obj_string); + + return obj_string; +} + /** * cal_client_update_object: * @client: A calendar client. @@ -1602,10 +1851,11 @@ cal_client_update_object (CalClient *client, CalComponent *comp) retval = FALSE; cal_component_commit_sequence (comp); - obj_string = cal_component_get_as_string (comp); cal_component_get_uid (comp, &uid); + obj_string = cal_client_get_component_as_string (client, comp); + CORBA_exception_init (&ev); GNOME_Evolution_Calendar_Cal_updateObject (priv->cal, (char *) uid, obj_string, &ev); g_free (obj_string); -- cgit v1.2.3