/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* e-itip-control.c * * Copyright (C) 2001 Ximian, Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. * * 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. * * Author: JP Rosevear */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "calendar-config.h" #include "itip-utils.h" #include "e-itip-control.h" struct _EItipControlPrivate { GtkWidget *html; GPtrArray *event_clients; CalClient *event_client; GPtrArray *task_clients; CalClient *task_client; char *vcalendar; CalComponent *comp; icalcomponent *main_comp; icalcomponent *ical_comp; icalcomponent *top_level; icalcompiter iter; icalproperty_method method; int current; int total; GList *addresses; gchar *from_address; gchar *my_address; }; /* HTML Strings */ #define HTML_BODY_START "" #define HTML_SEP "
" #define HTML_BODY_END "" #define HTML_FOOTER "" extern EvolutionShellClient *global_shell_client; /* We intentionally use "calendar" instead of "calendar/*" here. We * don't want public calendars. */ static const char *calendar_types[] = { "calendar", NULL }; static const char *tasks_types[] = { "tasks", NULL }; static void class_init (EItipControlClass *klass); static void init (EItipControl *itip); static void destroy (GtkObject *obj); static void url_requested_cb (GtkHTML *html, const gchar *url, GtkHTMLStream *handle, gpointer data); static gboolean object_requested_cb (GtkHTML *html, GtkHTMLEmbedded *eb, gpointer data); static void ok_clicked_cb (GtkHTML *html, const gchar *method, const gchar *url, const gchar *encoding, gpointer data); static GtkVBoxClass *parent_class = NULL; GtkType e_itip_control_get_type (void) { static GtkType type = 0; if (type == 0) { static const GtkTypeInfo info = { "EItipControl", sizeof (EItipControl), sizeof (EItipControlClass), (GtkClassInitFunc) class_init, (GtkObjectInitFunc) init, /* reserved_1 */ NULL, /* reserved_2 */ NULL, (GtkClassInitFunc) NULL, }; type = gtk_type_unique (gtk_vbox_get_type (), &info); } return type; } static void class_init (EItipControlClass *klass) { GtkObjectClass *object_class; object_class = GTK_OBJECT_CLASS (klass); parent_class = gtk_type_class (gtk_vbox_get_type ()); object_class->destroy = destroy; } /* Calendar Server routines */ static void start_calendar_server_cb (CalClient *cal_client, CalClientOpenStatus status, gpointer data) { gboolean *success = data; if (status == CAL_CLIENT_OPEN_SUCCESS) *success = TRUE; else *success = FALSE; gtk_main_quit (); /* end the sub event loop */ } static CalClient * start_calendar_server (char *uri) { CalClient *client; gboolean success = FALSE; client = cal_client_new (); gtk_signal_connect (GTK_OBJECT (client), "cal_opened", start_calendar_server_cb, &success); cal_client_open_calendar (client, uri, TRUE); /* run a sub event loop to turn cal-client's async load notification into a synchronous call */ gtk_main (); if (success) return client; gtk_object_unref (GTK_OBJECT (client)); return NULL; } static CalClient * start_default_server (gboolean tasks) { CalClient *client; gboolean success = FALSE; client = cal_client_new (); gtk_signal_connect (GTK_OBJECT (client), "cal_opened", start_calendar_server_cb, &success); if (tasks) { if (!cal_client_open_default_tasks (client, FALSE)) goto error; } else { if (!cal_client_open_default_calendar (client, FALSE)) goto error; } /* run a sub event loop to turn cal-client's async load notification into a synchronous call */ gtk_main (); if (success) return client; error: gtk_object_unref (GTK_OBJECT (client)); return NULL; } static GPtrArray * get_servers (EvolutionShellClient *shell_client, const char *possible_types[], gboolean tasks) { GNOME_Evolution_StorageRegistry registry; GNOME_Evolution_StorageRegistry_StorageList *storage_list; GPtrArray *servers; int i, j, k; CORBA_Environment ev; servers = g_ptr_array_new (); bonobo_object_ref (BONOBO_OBJECT (shell_client)); registry = evolution_shell_client_get_storage_registry_interface (shell_client); CORBA_exception_init (&ev); storage_list = GNOME_Evolution_StorageRegistry_getStorageList (registry, &ev); if (BONOBO_EX (&ev)) { CORBA_exception_free (&ev); return servers; } for (i = 0; i < storage_list->_length; i++) { GNOME_Evolution_Storage storage; GNOME_Evolution_FolderList *folder_list; storage = storage_list->_buffer[i]; folder_list = GNOME_Evolution_Storage__get_folderList (storage, &ev); for (j = 0; j < folder_list->_length; j++) { GNOME_Evolution_Folder folder; folder = folder_list->_buffer[j]; for (k = 0; possible_types[k] != NULL; k++) { CalClient *client; char *uri; if (strcmp (possible_types[k], folder.type)) continue; uri = cal_util_expand_uri (folder.physicalUri, tasks); client = start_calendar_server (uri); if (client != NULL) g_ptr_array_add (servers, client); g_free (uri); break; } } CORBA_free (folder_list); } bonobo_object_unref (BONOBO_OBJECT (shell_client)); return servers; } static CalClient * find_server (GPtrArray *servers, CalComponent *comp) { const char *uid; int i; cal_component_get_uid (comp, &uid); for (i = 0; i < servers->len; i++) { CalClient *client; CalComponent *found_comp; CalClientGetStatus status; client = g_ptr_array_index (servers, i); status = cal_client_get_object (client, uid, &found_comp); if (status == CAL_CLIENT_GET_SUCCESS) { gtk_object_unref (GTK_OBJECT (found_comp)); gtk_object_ref (GTK_OBJECT (client)); return client; } } return NULL; } static void init (EItipControl *itip) { EItipControlPrivate *priv; GtkWidget *scrolled_window; priv = g_new0 (EItipControlPrivate, 1); itip->priv = priv; /* Addresses */ priv->addresses = itip_addresses_get (); /* Initialize the cal clients */ priv->event_clients = NULL; priv->event_client = NULL; priv->task_clients = NULL; priv->task_client = NULL; /* Html Widget */ priv->html = gtk_html_new (); gtk_html_set_default_content_type (GTK_HTML (priv->html), "text/html; charset=utf-8"); gtk_widget_show (priv->html); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scrolled_window); gtk_container_add (GTK_CONTAINER (scrolled_window), priv->html); gtk_widget_set_usize (scrolled_window, 600, 400); gtk_box_pack_start (GTK_BOX (itip), scrolled_window, FALSE, FALSE, 4); gtk_signal_connect (GTK_OBJECT (priv->html), "url_requested", url_requested_cb, itip); gtk_signal_connect (GTK_OBJECT (priv->html), "object_requested", GTK_SIGNAL_FUNC (object_requested_cb), itip); gtk_signal_connect (GTK_OBJECT (priv->html), "submit", ok_clicked_cb, itip); } static void clean_up (EItipControl *itip) { EItipControlPrivate *priv; priv = itip->priv; g_free (priv->vcalendar); priv->vcalendar = NULL; if (priv->comp) gtk_object_unref (GTK_OBJECT (priv->comp)); priv->comp = NULL; icalcomponent_free (priv->top_level); priv->top_level = NULL; icalcomponent_free (priv->main_comp); priv->main_comp = NULL; priv->ical_comp = NULL; priv->current = 0; priv->total = 0; g_free (priv->my_address); priv->my_address = NULL; g_free (priv->from_address); priv->from_address = NULL; } static void destroy (GtkObject *obj) { EItipControl *itip = E_ITIP_CONTROL (obj); EItipControlPrivate *priv; int i; priv = itip->priv; clean_up (itip); itip_addresses_free (priv->addresses); priv->addresses = NULL; if (priv->event_clients) { for (i = 0; i < priv->event_clients->len; i++) gtk_object_unref (GTK_OBJECT (g_ptr_array_index (priv->event_clients, i))); g_ptr_array_free (priv->event_clients, TRUE); } if (priv->task_clients) { for (i = 0; i < priv->task_clients->len; i++) gtk_object_unref (GTK_OBJECT (g_ptr_array_index (priv->task_clients, i))); g_ptr_array_free (priv->task_clients, TRUE); } g_free (priv); if (GTK_OBJECT_CLASS (parent_class)->destroy) (* GTK_OBJECT_CLASS (parent_class)->destroy) (obj); } GtkWidget * e_itip_control_new (void) { return gtk_type_new (E_TYPE_ITIP_CONTROL); } static void find_my_address (EItipControl *itip, icalcomponent *ical_comp) { EItipControlPrivate *priv; icalproperty *prop; char *my_alt_address = NULL; priv = itip->priv; for (prop = icalcomponent_get_first_property (ical_comp, ICAL_ATTENDEE_PROPERTY); prop != NULL; prop = icalcomponent_get_next_property (ical_comp, ICAL_ATTENDEE_PROPERTY)) { icalvalue *value; icalparameter *param; const char *attendee, *name; char *attendee_clean, *name_clean; GList *l; value = icalproperty_get_value (prop); if (value != NULL) { attendee = icalvalue_get_string (value); attendee_clean = g_strdup (itip_strip_mailto (attendee)); attendee_clean = g_strstrip (attendee_clean); } else { attendee = NULL; attendee_clean = NULL; } param = icalproperty_get_first_parameter (prop, ICAL_CN_PARAMETER); if (param != NULL) { name = icalparameter_get_cn (param); name_clean = g_strdup (name); name_clean = g_strstrip (name_clean); } else { name = NULL; name_clean = NULL; } for (l = priv->addresses; l != NULL; l = l->next) { ItipAddress *a = l->data; /* Check for a matching address */ if (attendee_clean != NULL && !g_strcasecmp (a->address, attendee_clean)) { priv->my_address = g_strdup (a->address); g_free (attendee_clean); g_free (name_clean); return; } /* Check for a matching cname to fall back on */ if (name_clean != NULL && !g_strcasecmp (a->name, name_clean)) my_alt_address = g_strdup (attendee_clean); } g_free (attendee_clean); g_free (name_clean); } priv->my_address = my_alt_address; } static icalproperty * find_attendee (icalcomponent *ical_comp, const char *address) { icalproperty *prop; if (address == NULL) return NULL; for (prop = icalcomponent_get_first_property (ical_comp, ICAL_ATTENDEE_PROPERTY); prop != NULL; prop = icalcomponent_get_next_property (ical_comp, ICAL_ATTENDEE_PROPERTY)) { icalvalue *value; const char *attendee; char *text; value = icalproperty_get_value (prop); if (!value) continue; attendee = icalvalue_get_string (value); text = g_strdup (itip_strip_mailto (attendee)); text = g_strstrip (text); if (!g_strcasecmp (address, text)) { g_free (text); break; } g_free (text); } return prop; } static void write_label_piece (EItipControl *itip, CalComponentDateTime *dt, char *buffer, int size, const char *stext, const char *etext) { EItipControlPrivate *priv; struct tm tmp_tm; char time_buf[64], *time_utf8; icaltimezone *zone = NULL; char *display_name; priv = itip->priv; /* UTC times get converted to the current timezone. This is done for the COMPLETED property, which is always in UTC, and also because Outlook sends simple events as UTC times. */ if (dt->value->is_utc) { char *location = calendar_config_get_timezone (); zone = icaltimezone_get_builtin_timezone (location); icaltimezone_convert_time (dt->value, icaltimezone_get_utc_timezone (), zone); } tmp_tm = icaltimetype_to_tm (dt->value); if (stext != NULL) strcat (buffer, stext); e_time_format_date_and_time (&tmp_tm, calendar_config_get_24_hour_format (), FALSE, FALSE, time_buf, sizeof (time_buf)); time_utf8 = e_utf8_from_locale_string (time_buf); strcat (buffer, time_utf8); g_free (time_utf8); if (!dt->value->is_utc && dt->tzid) { zone = icalcomponent_get_timezone (priv->top_level, dt->tzid); } /* Output timezone after time, e.g. " America/New_York". */ if (zone) { /* Note that this returns UTF-8, since all iCalendar data is UTF-8. But it probably is not translated. */ display_name = icaltimezone_get_display_name (zone); if (display_name && *display_name) { strcat (buffer, " "); /* We check if it is one of our builtin timezone names, in which case we call gettext to translate it, and we need to convert to UTF-8. If it isn't a builtin timezone name, we use it as-is, as it is already UTF-8. */ if (icaltimezone_get_builtin_timezone (display_name)) { strcat (buffer, U_(display_name)); } else { strcat (buffer, display_name); } } } if (etext != NULL) strcat (buffer, etext); } static void set_date_label (EItipControl *itip, GtkHTML *html, GtkHTMLStream *html_stream, CalComponent *comp) { EItipControlPrivate *priv; CalComponentDateTime datetime; static char buffer[1024]; gboolean wrote = FALSE, task_completed = FALSE; CalComponentVType type; priv = itip->priv; type = cal_component_get_vtype (comp); buffer[0] = '\0'; cal_component_get_dtstart (comp, &datetime); if (datetime.value) { write_label_piece (itip, &datetime, buffer, 1024, U_("Starts: "), "
"); gtk_html_write (html, html_stream, buffer, strlen(buffer)); wrote = TRUE; } cal_component_free_datetime (&datetime); buffer[0] = '\0'; cal_component_get_dtend (comp, &datetime); if (datetime.value){ write_label_piece (itip, &datetime, buffer, 1024, U_("Ends: "), "
"); gtk_html_write (html, html_stream, buffer, strlen (buffer)); wrote = TRUE; } cal_component_free_datetime (&datetime); buffer[0] = '\0'; datetime.tzid = NULL; cal_component_get_completed (comp, &datetime.value); if (type == CAL_COMPONENT_TODO && datetime.value) { /* Pass TRUE as is_utc, so it gets converted to the current timezone. */ datetime.value->is_utc = TRUE; write_label_piece (itip, &datetime, buffer, 1024, U_("Completed: "), "
"); gtk_html_write (html, html_stream, buffer, strlen (buffer)); wrote = TRUE; task_completed = TRUE; } cal_component_free_datetime (&datetime); buffer[0] = '\0'; cal_component_get_due (comp, &datetime); if (type == CAL_COMPONENT_TODO && !task_completed && datetime.value) { write_label_piece (itip, &datetime, buffer, 1024, U_("Due: "), "
"); gtk_html_write (html, html_stream, buffer, strlen (buffer)); wrote = TRUE; } cal_component_free_datetime (&datetime); if (wrote) gtk_html_stream_printf (html_stream, "
"); } static void set_message (GtkHTML *html, GtkHTMLStream *html_stream, const gchar *message, gboolean err) { if (message == NULL) return; if (err) { gtk_html_stream_printf (html_stream, "%s

", message); } else { gtk_html_stream_printf (html_stream, "%s

", message); } } static void write_error_html (EItipControl *itip, const gchar *itip_err) { EItipControlPrivate *priv; GtkHTMLStream *html_stream; priv = itip->priv; /* Html widget */ html_stream = gtk_html_begin (GTK_HTML (priv->html)); gtk_html_stream_printf (html_stream, "%s", U_("iCalendar Information")); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_BODY_START, strlen(HTML_BODY_START)); /* The table */ gtk_html_stream_printf (html_stream, ""); /* The column for the image */ gtk_html_stream_printf (html_stream, ""); gtk_html_stream_printf (html_stream, "
"); /* The image */ gtk_html_stream_printf (html_stream, ""); /* Title */ set_message (GTK_HTML (priv->html), html_stream, U_("iCalendar Error"), TRUE); /* Error */ gtk_html_write (GTK_HTML (priv->html), html_stream, itip_err, strlen(itip_err)); /* Clean up */ gtk_html_stream_printf (html_stream, "
"); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_BODY_END, strlen(HTML_BODY_END)); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_FOOTER, strlen(HTML_FOOTER)); gtk_html_end (GTK_HTML (priv->html), html_stream, GTK_HTML_STREAM_OK); } static void write_html (EItipControl *itip, const gchar *itip_desc, const gchar *itip_title, const gchar *options) { EItipControlPrivate *priv; GtkHTMLStream *html_stream; CalComponentText text; CalComponentOrganizer organizer; CalComponentAttendee *attendee; GSList *attendees, *l = NULL; const char *string; gchar *html; const gchar *const_html; priv = itip->priv; /* Html widget */ html_stream = gtk_html_begin (GTK_HTML (priv->html)); gtk_html_stream_printf (html_stream, "%s", U_("iCalendar Information")); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_BODY_START, strlen(HTML_BODY_START)); /* The table */ const_html = ""; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); /* The column for the image */ const_html = ""; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); const_html = "
"; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); /* The image */ const_html = ""; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); switch (priv->method) { case ICAL_METHOD_REFRESH: case ICAL_METHOD_REPLY: /* An attendee sent this */ cal_component_get_attendee_list (priv->comp, &attendees); if (attendees != NULL) { attendee = attendees->data; html = g_strdup_printf (itip_desc, attendee->cn ? attendee->cn : itip_strip_mailto (attendee->value)); } else { html = g_strdup_printf (itip_desc, U_("An unknown person")); } break; case ICAL_METHOD_PUBLISH: case ICAL_METHOD_REQUEST: case ICAL_METHOD_ADD: case ICAL_METHOD_CANCEL: default: /* The organizer sent this */ cal_component_get_organizer (priv->comp, &organizer); if (organizer.value != NULL) html = g_strdup_printf (itip_desc, organizer.cn ? organizer.cn : itip_strip_mailto (organizer.value)); else html = g_strdup_printf (itip_desc, U_("An unknown person")); break; } gtk_html_write (GTK_HTML (priv->html), html_stream, html, strlen(html)); g_free (html); /* Describe what the user can do */ const_html = U_("
Please review the following information, " "and then select an action from the menu below."); gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); /* Separator */ gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_SEP, strlen (HTML_SEP)); /* Title */ set_message (GTK_HTML (priv->html), html_stream, itip_title, FALSE); /* Date information */ set_date_label (itip, GTK_HTML (priv->html), html_stream, priv->comp); /* Summary */ cal_component_get_summary (priv->comp, &text); html = e_text_to_html (text.value ? text.value : U_("None"), E_TEXT_TO_HTML_CONVERT_NL); gtk_html_stream_printf (html_stream, "%s
%s

", U_("Summary:"), html); g_free (html); /* Location */ cal_component_get_location (priv->comp, &string); if (string != NULL) { html = e_text_to_html (string, E_TEXT_TO_HTML_CONVERT_NL); gtk_html_stream_printf (html_stream, "%s
%s

", U_("Location:"), html); g_free (html); } /* Status */ if (priv->method == ICAL_METHOD_REPLY) { GSList *alist; cal_component_get_attendee_list (priv->comp, &alist); if (alist != NULL) { CalComponentAttendee *a = alist->data; gtk_html_stream_printf (html_stream, "%s
", U_("Status:")); switch (a->status) { case ICAL_PARTSTAT_ACCEPTED: gtk_html_stream_printf (html_stream, "%s

", U_("Accepted")); break; case ICAL_PARTSTAT_TENTATIVE: gtk_html_stream_printf (html_stream, "%s

", U_("Tentatively Accepted")); break; case ICAL_PARTSTAT_DECLINED: gtk_html_stream_printf (html_stream, "%s

", U_("Declined")); break; default: gtk_html_stream_printf (html_stream, "%s

", U_("Unknown")); } } cal_component_free_attendee_list (alist); } /* Description */ cal_component_get_description_list (priv->comp, &l); if (l) text = *((CalComponentText *)l->data); if (l && text.value) { html = e_text_to_html (text.value, E_TEXT_TO_HTML_CONVERT_NL); gtk_html_stream_printf (html_stream, "%s
%s", U_("Description:"), html); g_free (html); } cal_component_free_text_list (l); /* Separator */ gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_SEP, strlen (HTML_SEP)); /* Options */ if (options != NULL) { const_html = "
"; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen (const_html)); gtk_html_write (GTK_HTML (priv->html), html_stream, options, strlen (options)); } const_html = "
"; gtk_html_write (GTK_HTML (priv->html), html_stream, const_html, strlen(const_html)); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_BODY_END, strlen(HTML_BODY_END)); gtk_html_write (GTK_HTML (priv->html), html_stream, HTML_FOOTER, strlen(HTML_FOOTER)); gtk_html_end (GTK_HTML (priv->html), html_stream, GTK_HTML_STREAM_OK); } static char* get_publish_options (gboolean selector) { char *html; html = g_strdup_printf ("
%s " "    " "" "
", U_("Choose an action:"), U_("Update"), U_("OK")); if (selector) { char *sel; sel = g_strconcat (html, "", NULL); g_free (html); html = sel; } return html; } static char* get_request_options (gboolean selector) { char *html; html = g_strdup_printf ("
%s " "  " "%s  " "
" "
", U_("Choose an action:"), U_("Accept"), U_("Tentatively accept"), U_("Decline"), U_("RSVP"), U_("OK")); if (selector) { char *sel; sel = g_strconcat (html, "", NULL); g_free (html); html = sel; } return html; } static char* get_request_fb_options () { return g_strdup_printf ("
%s " "    " "" "
", U_("Choose an action:"), U_("Send Free/Busy Information"), U_("OK")); } static char* get_reply_options () { return g_strdup_printf ("
%s " "    " "" "
", U_("Choose an action:"), U_("Update respondent status"), U_("OK")); } static char* get_refresh_options () { return g_strdup_printf ("
%s " "    " "" "
", U_("Choose an action:"), U_("Send Latest Information"), U_("OK")); } static char* get_cancel_options () { return g_strdup_printf ("
%s " "    " "" "
", U_("Choose an action:"), U_("Cancel"), U_("OK")); } static CalComponent * get_real_item (EItipControl *itip) { EItipControlPrivate *priv; CalComponent *comp; CalComponentVType type; CalClientGetStatus status = CAL_CLIENT_GET_NOT_FOUND; const char *uid; priv = itip->priv; type = cal_component_get_vtype (priv->comp); cal_component_get_uid (priv->comp, &uid); switch (type) { case CAL_COMPONENT_EVENT: if (priv->event_client != NULL) status = cal_client_get_object (priv->event_client, uid, &comp); break; case CAL_COMPONENT_TODO: if (priv->task_client != NULL) status = cal_client_get_object (priv->task_client, uid, &comp); break; default: status = CAL_CLIENT_GET_NOT_FOUND; } if (status != CAL_CLIENT_GET_SUCCESS) return NULL; return comp; } static void adjust_item (EItipControl *itip, CalComponent *comp) { CalComponent *real_comp; real_comp = get_real_item (itip); if (real_comp != NULL) { CalComponentText text; const char *string; GSList *l; cal_component_get_summary (real_comp, &text); cal_component_set_summary (comp, &text); cal_component_get_location (real_comp, &string); cal_component_set_location (comp, string); cal_component_get_description_list (real_comp, &l); cal_component_set_description_list (comp, l); cal_component_free_text_list (l); gtk_object_unref (GTK_OBJECT (real_comp)); } else { CalComponentText text = {_("Unknown"), NULL}; cal_component_set_summary (comp, &text); } } static void show_current_event (EItipControl *itip) { EItipControlPrivate *priv; const gchar *itip_title, *itip_desc; char *options; priv = itip->priv; priv->event_client = find_server (priv->event_clients, priv->comp); switch (priv->method) { case ICAL_METHOD_PUBLISH: itip_desc = U_("%s has published meeting information."); itip_title = U_("Meeting Information"); options = get_publish_options (priv->event_client ? FALSE : TRUE); break; case ICAL_METHOD_REQUEST: itip_desc = U_("%s requests your presence at a meeting."); itip_title = U_("Meeting Proposal"); options = get_request_options (priv->event_client ? FALSE : TRUE); break; case ICAL_METHOD_ADD: itip_desc = U_("%s wishes to add to an existing meeting."); itip_title = U_("Meeting Update"); options = get_publish_options (priv->event_client ? FALSE : TRUE); break; case ICAL_METHOD_REFRESH: itip_desc = U_("%s wishes to receive the latest meeting information."); itip_title = U_("Meeting Update Request"); options = get_refresh_options (); /* Provide extra info, since its not in the component */ adjust_item (itip, priv->comp); break; case ICAL_METHOD_REPLY: itip_desc = U_("%s has replied to a meeting request."); itip_title = U_("Meeting Reply"); options = get_reply_options (); /* Provide extra info, since might not be in the component */ adjust_item (itip, priv->comp); break; case ICAL_METHOD_CANCEL: itip_desc = U_("%s has cancelled a meeting."); itip_title = U_("Meeting Cancellation"); options = get_cancel_options (); /* Provide extra info, since might not be in the component */ adjust_item (itip, priv->comp); break; default: itip_desc = U_("%s has sent an unintelligible message."); itip_title = U_("Bad Meeting Message"); options = NULL; } write_html (itip, itip_desc, itip_title, options); g_free (options); } static void show_current_todo (EItipControl *itip) { EItipControlPrivate *priv; const gchar *itip_title, *itip_desc; char *options; priv = itip->priv; priv->task_client = find_server (priv->task_clients, priv->comp); switch (priv->method) { case ICAL_METHOD_PUBLISH: itip_desc = U_("%s has published task information."); itip_title = U_("Task Information"); options = get_publish_options (priv->task_client ? FALSE : TRUE); break; case ICAL_METHOD_REQUEST: itip_desc = U_("%s requests you perform a task."); itip_title = U_("Task Proposal"); options = get_request_options (priv->task_client ? FALSE : TRUE); break; case ICAL_METHOD_ADD: itip_desc = U_("%s wishes to add to an existing task."); itip_title = U_("Task Update"); options = get_publish_options (priv->task_client ? FALSE : TRUE); break; case ICAL_METHOD_REFRESH: itip_desc = U_("%s wishes to receive the latest task information."); itip_title = U_("Task Update Request"); options = get_refresh_options (); /* Provide extra info, since its not in the component */ adjust_item (itip, priv->comp); break; case ICAL_METHOD_REPLY: itip_desc = U_("%s has replied to a task assignment."); itip_title = U_("Task Reply"); options = get_reply_options (); /* Provide extra info, since might not be in the component */ adjust_item (itip, priv->comp); break; case ICAL_METHOD_CANCEL: itip_desc = U_("%s has cancelled a task."); itip_title = U_("Task Cancellation"); options = get_cancel_options (); /* Provide extra info, since might not be in the component */ adjust_item (itip, priv->comp); break; default: itip_desc = U_("%s has sent an unintelligible message."); itip_title = U_("Bad Task Message"); options = NULL; } write_html (itip, itip_desc, itip_title, options); g_free (options); } static void show_current_freebusy (EItipControl *itip) { EItipControlPrivate *priv; const gchar *itip_title, *itip_desc; char *options; priv = itip->priv; switch (priv->method) { case ICAL_METHOD_PUBLISH: itip_desc = U_("%s has published free/busy information."); itip_title = U_("Free/Busy Information"); options = NULL; break; case ICAL_METHOD_REQUEST: itip_desc = U_("%s requests your free/busy information."); itip_title = U_("Free/Busy Request"); options = get_request_fb_options (); break; case ICAL_METHOD_REPLY: itip_desc = U_("%s has replied to a free/busy request."); itip_title = U_("Free/Busy Reply"); options = NULL; break; default: itip_desc = U_("%s has sent an unintelligible message."); itip_title = U_("Bad Free/Busy Message"); options = NULL; } write_html (itip, itip_desc, itip_title, options); g_free (options); } static icalcomponent * get_next (icalcompiter *iter) { icalcomponent *ret = NULL; icalcomponent_kind kind; do { icalcompiter_next (iter); ret = icalcompiter_deref (iter); kind = icalcomponent_isa (ret); } while (ret != NULL && kind != ICAL_VEVENT_COMPONENT && kind != ICAL_VTODO_COMPONENT && kind != ICAL_VFREEBUSY_COMPONENT); return ret; } static void show_current (EItipControl *itip) { EItipControlPrivate *priv; CalComponentVType type; icalcomponent *alarm_comp; icalcompiter alarm_iter; priv = itip->priv; if (priv->comp) gtk_object_unref (GTK_OBJECT (priv->comp)); if (priv->event_client != NULL) gtk_object_unref (GTK_OBJECT (priv->event_client)); priv->event_client = NULL; if (priv->task_client != NULL) gtk_object_unref (GTK_OBJECT (priv->task_client)); priv->task_client = NULL; /* Strip out alarms for security purposes */ alarm_iter = icalcomponent_begin_component (priv->ical_comp, ICAL_VALARM_COMPONENT); while ((alarm_comp = icalcompiter_deref (&alarm_iter)) != NULL) { icalcomponent_remove_component (priv->ical_comp, alarm_comp); icalcompiter_next (&alarm_iter); } priv->comp = cal_component_new (); if (!cal_component_set_icalcomponent (priv->comp, priv->ical_comp)) { write_error_html (itip, U_("The message does not appear to be properly formed")); gtk_object_unref (GTK_OBJECT (priv->comp)); priv->comp = NULL; return; }; /* Add default reminder if the config says so */ if (calendar_config_get_use_default_reminder ()) { CalComponent *acomp; int interval; CalUnits units; CalAlarmTrigger trigger; interval = calendar_config_get_default_reminder_interval (); units = calendar_config_get_default_reminder_units (); acomp = cal_component_alarm_new (); cal_component_alarm_set_action (acomp, CAL_ALARM_DISPLAY); trigger.type = CAL_ALARM_TRIGGER_RELATIVE_START; memset (&trigger.u.rel_duration, 0, sizeof (trigger.u.rel_duration)); trigger.u.rel_duration.is_neg = TRUE; switch (units) { case CAL_MINUTES: trigger.u.rel_duration.minutes = interval; break; case CAL_HOURS: trigger.u.rel_duration.hours = interval; break; case CAL_DAYS: trigger.u.rel_duration.days = interval; break; default: g_assert_not_reached (); } cal_component_alarm_set_trigger (acomp, trigger); cal_component_add_alarm (priv->comp, acomp); cal_component_alarm_free (acomp); } type = cal_component_get_vtype (priv->comp); switch (type) { case CAL_COMPONENT_EVENT: if (!priv->event_clients) priv->event_clients = get_servers (global_shell_client, calendar_types, FALSE); show_current_event (itip); break; case CAL_COMPONENT_TODO: if (!priv->task_clients) priv->task_clients = get_servers (global_shell_client, tasks_types, FALSE); show_current_todo (itip); break; case CAL_COMPONENT_FREEBUSY: show_current_freebusy (itip); break; default: write_error_html (itip, U_("The message contains only unsupported requests.")); } find_my_address (itip, priv->ical_comp); } void e_itip_control_set_data (EItipControl *itip, const gchar *text) { EItipControlPrivate *priv; icalproperty *prop; icalcomponent_kind kind = ICAL_NO_COMPONENT; icalcomponent *tz_comp; icalcompiter tz_iter; priv = itip->priv; clean_up (itip); priv->comp = NULL; priv->total = 0; priv->current = 0; priv->vcalendar = g_strdup (text); priv->top_level = cal_util_new_top_level (); priv->main_comp = icalparser_parse_string (priv->vcalendar); if (priv->main_comp == NULL) { write_error_html (itip, U_("The attachment does not contain a valid calendar message")); return; } prop = icalcomponent_get_first_property (priv->main_comp, ICAL_METHOD_PROPERTY); if (prop == NULL) { write_error_html (itip, U_("The attachment does not contain a valid calendar message")); return; } priv->method = icalproperty_get_method (prop); tz_iter = icalcomponent_begin_component (priv->main_comp, ICAL_VTIMEZONE_COMPONENT); while ((tz_comp = icalcompiter_deref (&tz_iter)) != NULL) { icalcomponent *clone; clone = icalcomponent_new_clone (tz_comp); icalcomponent_add_component (priv->top_level, clone); icalcompiter_next (&tz_iter); } priv->iter = icalcomponent_begin_component (priv->main_comp, ICAL_ANY_COMPONENT); priv->ical_comp = icalcompiter_deref (&priv->iter); kind = icalcomponent_isa (priv->ical_comp); if (kind != ICAL_VEVENT_COMPONENT && kind != ICAL_VTODO_COMPONENT && kind != ICAL_VFREEBUSY_COMPONENT) priv->ical_comp = get_next (&priv->iter); if (priv->ical_comp == NULL) { write_error_html (itip, U_("The attachment has no viewable calendar items")); return; } priv->total = icalcomponent_count_components (priv->main_comp, ICAL_VEVENT_COMPONENT); priv->total += icalcomponent_count_components (priv->main_comp, ICAL_VTODO_COMPONENT); priv->total += icalcomponent_count_components (priv->main_comp, ICAL_VFREEBUSY_COMPONENT); if (priv->total > 0) priv->current = 1; else priv->current = 0; show_current (itip); } gchar * e_itip_control_get_data (EItipControl *itip) { EItipControlPrivate *priv; priv = itip->priv; return g_strdup (priv->vcalendar); } gint e_itip_control_get_data_size (EItipControl *itip) { EItipControlPrivate *priv; priv = itip->priv; if (priv->vcalendar == NULL) return 0; return strlen (priv->vcalendar); } void e_itip_control_set_from_address (EItipControl *itip, const gchar *address) { EItipControlPrivate *priv; priv = itip->priv; if (priv->from_address) g_free (priv->from_address); priv->from_address = g_strdup (address); } const gchar * e_itip_control_get_from_address (EItipControl *itip) { EItipControlPrivate *priv; priv = itip->priv; return priv->from_address; } static gboolean change_status (icalcomponent *ical_comp, const char *address, icalparameter_partstat status) { icalproperty *prop; prop = find_attendee (ical_comp, address); if (prop) { icalparameter *param; icalproperty_remove_parameter (prop, ICAL_PARTSTAT_PARAMETER); param = icalparameter_new_partstat (status); icalproperty_add_parameter (prop, param); } else { icalparameter *param; if (address != NULL) { prop = icalproperty_new_attendee (address); icalcomponent_add_property (ical_comp, prop); param = icalparameter_new_role (ICAL_ROLE_OPTPARTICIPANT); icalproperty_add_parameter (prop, param); param = icalparameter_new_partstat (status); icalproperty_add_parameter (prop, param); } else { ItipAddress *a; a = itip_addresses_get_default (); prop = icalproperty_new_attendee (a->address); icalcomponent_add_property (ical_comp, prop); param = icalparameter_new_cn (a->name); icalproperty_add_parameter (prop, param); param = icalparameter_new_role (ICAL_ROLE_REQPARTICIPANT); icalproperty_add_parameter (prop, param); param = icalparameter_new_partstat (status); icalproperty_add_parameter (prop, param); itip_address_free (a); } } return TRUE; } static void update_item (EItipControl *itip) { EItipControlPrivate *priv; struct icaltimetype stamp; icalproperty *prop; icalcomponent *clone; CalClient *client; CalComponentVType type; GtkWidget *dialog; CalClientResult result; priv = itip->priv; /* Set X-MICROSOFT-CDO-REPLYTIME to record the time at which * the user accepted/declined the request. (Outlook ignores * SEQUENCE in REPLY reponses and instead requires that each * updated response have a later REPLYTIME than the previous * one.) This also ends up getting saved in our own copy of * the meeting, though there's currently no way to see that * information (unless it's being saved to an Exchange folder * and you then look at it in Outlook). */ stamp = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); prop = icalproperty_new_x (icaltime_as_ical_string (stamp)); icalproperty_set_x_name (prop, "X-MICROSOFT-CDO-REPLYTIME"); icalcomponent_add_property (priv->ical_comp, prop); type = cal_component_get_vtype (priv->comp); if (type == CAL_COMPONENT_TODO) client = priv->task_client; else client = priv->event_client; clone = icalcomponent_new_clone (priv->ical_comp); icalcomponent_add_component (priv->top_level, clone); result = cal_client_update_objects (client, priv->top_level); switch (result) { case CAL_CLIENT_RESULT_INVALID_OBJECT : dialog = gnome_warning_dialog (_("Object is invalid and cannot be updated\n")); break; case CAL_CLIENT_RESULT_CORBA_ERROR : dialog = gnome_warning_dialog (_("There was an error on the CORBA system\n")); break; case CAL_CLIENT_RESULT_NOT_FOUND : dialog = gnome_warning_dialog (_("Object could not be found\n")); break; case CAL_CLIENT_RESULT_PERMISSION_DENIED : dialog = gnome_warning_dialog (_("You don't have permissions to update the calendar\n")); break; case CAL_CLIENT_RESULT_SUCCESS : dialog = gnome_ok_dialog (_("Update complete\n")); break; default : dialog = gnome_warning_dialog (_("Calendar file could not be updated!\n")); break; } gnome_dialog_run_and_close (GNOME_DIALOG (dialog)); icalcomponent_remove_component (priv->top_level, clone); } static void update_attendee_status (EItipControl *itip) { EItipControlPrivate *priv; CalClient *client; CalClientGetStatus status; CalComponent *comp = NULL; CalComponentVType type; const char *uid; GtkWidget *dialog; CalClientResult result; priv = itip->priv; type = cal_component_get_vtype (priv->comp); if (type == CAL_COMPONENT_TODO) client = priv->task_client; else client = priv->event_client; if (client == NULL) { dialog = gnome_warning_dialog (_("Attendee status can not be updated " "because the item no longer exists")); goto cleanup; } /* Obtain our version */ cal_component_get_uid (priv->comp, &uid); status = cal_client_get_object (client, uid, &comp); if (status == CAL_CLIENT_GET_SUCCESS) { GSList *attendees; cal_component_get_attendee_list (priv->comp, &attendees); if (attendees != NULL) { CalComponentAttendee *a = attendees->data; icalproperty *prop; prop = find_attendee (cal_component_get_icalcomponent (comp), itip_strip_mailto (a->value)); if (prop == NULL) { dialog = gnome_question_dialog_modal (_("This response is not from a current " "attendee. Add as an attendee?"), NULL, NULL); if (gnome_dialog_run_and_close (GNOME_DIALOG (dialog)) == GNOME_YES) { change_status (cal_component_get_icalcomponent (comp), itip_strip_mailto (a->value), a->status); cal_component_rescan (comp); } else { goto cleanup; } } else if (a->status == ICAL_PARTSTAT_NONE || a->status == ICAL_PARTSTAT_X) { dialog = gnome_warning_dialog (_("Attendee status could " "not be updated because " "of an invalid status!\n")); goto cleanup; } else { change_status (cal_component_get_icalcomponent (comp), itip_strip_mailto (a->value), a->status); cal_component_rescan (comp); } } result = cal_client_update_object (client, comp); switch (result) { case CAL_CLIENT_RESULT_INVALID_OBJECT : dialog = gnome_warning_dialog (_("Object is invalid and cannot be updated\n")); break; case CAL_CLIENT_RESULT_CORBA_ERROR : dialog = gnome_warning_dialog (_("There was an error on the CORBA system\n")); break; case CAL_CLIENT_RESULT_NOT_FOUND : dialog = gnome_warning_dialog (_("Object could not be found\n")); break; case CAL_CLIENT_RESULT_PERMISSION_DENIED : dialog = gnome_warning_dialog (_("You don't have permissions to update the calendar\n")); break; case CAL_CLIENT_RESULT_SUCCESS : dialog = gnome_ok_dialog (_("Attendee status updated\n")); break; default : dialog = gnome_warning_dialog (_("Attendee status could not be updated!\n")); } } else { dialog = gnome_warning_dialog (_("Attendee status can not be updated " "because the item no longer exists")); } cleanup: if (comp != NULL) gtk_object_unref (GTK_OBJECT (comp)); gnome_dialog_run_and_close (GNOME_DIALOG (dialog)); } static void remove_item (EItipControl *itip) { EItipControlPrivate *priv; CalClient *client; CalComponentVType type; const char *uid; GtkWidget *dialog; priv = itip->priv; type = cal_component_get_vtype (priv->comp); if (type == CAL_COMPONENT_TODO) client = priv->task_client; else client = priv->event_client; if (client == NULL) return; cal_component_get_uid (priv->comp, &uid); if (cal_client_remove_object (client, uid) == CAL_CLIENT_RESULT_SUCCESS) { dialog = gnome_ok_dialog (_("Removal Complete")); gnome_dialog_run_and_close (GNOME_DIALOG (dialog)); } } static void send_item (EItipControl *itip) { EItipControlPrivate *priv; CalComponent *comp; CalComponentVType vtype; GtkWidget *dialog; priv = itip->priv; comp = get_real_item (itip); vtype = cal_component_get_vtype (comp); if (comp != NULL) { switch (vtype) { case CAL_COMPONENT_EVENT: itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, priv->event_client, NULL); break; case CAL_COMPONENT_TODO: itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, priv->task_client, NULL); break; default: itip_send_comp (CAL_COMPONENT_METHOD_REQUEST, comp, NULL, NULL); } gtk_object_unref (GTK_OBJECT (comp)); dialog = gnome_ok_dialog (_("Item sent!\n")); } else { dialog = gnome_warning_dialog (_("The item could not be sent!\n")); } gnome_dialog_run_and_close (GNOME_DIALOG (dialog)); } static void send_freebusy (EItipControl *itip) { EItipControlPrivate *priv; CalComponentDateTime datetime; time_t start, end; GtkWidget *dialog; GList *comp_list; icaltimezone *zone; priv = itip->priv; cal_component_get_dtstart (priv->comp, &datetime); if (datetime.tzid) { zone = icalcomponent_get_timezone (priv->top_level, datetime.tzid); } else { zone = NULL; } start = icaltime_as_timet_with_zone (*datetime.value, zone); cal_component_free_datetime (&datetime); cal_component_get_dtend (priv->comp, &datetime); if (datetime.tzid) { zone = icalcomponent_get_timezone (priv->top_level, datetime.tzid); } else { zone = NULL; } end = icaltime_as_timet_with_zone (*datetime.value, zone); cal_component_free_datetime (&datetime); comp_list = cal_client_get_free_busy (priv->event_client, NULL, start, end); if (comp_list) { GList *l; for (l = comp_list; l; l = l->next) { CalComponent *comp = CAL_COMPONENT (l->data); itip_send_comp (CAL_COMPONENT_METHOD_REPLY, comp, priv->event_client, NULL); gtk_object_unref (GTK_OBJECT (comp)); } dialog = gnome_ok_dialog (_("Item sent!\n")); g_list_free (comp_list); } else { dialog = gnome_warning_dialog (_("The item could not be sent!\n")); } gnome_dialog_run_and_close (GNOME_DIALOG (dialog)); } static void button_selected_cb (EvolutionFolderSelectorButton *button, GNOME_Evolution_Folder *folder, gpointer data) { EItipControl *itip = E_ITIP_CONTROL (data); EItipControlPrivate *priv; CalComponentVType type; char *uri; priv = itip->priv; type = cal_component_get_vtype (priv->comp); if (type == CAL_COMPONENT_TODO) uri = cal_util_expand_uri (folder->physicalUri, TRUE); else uri = cal_util_expand_uri (folder->physicalUri, FALSE); gtk_object_unref (GTK_OBJECT (priv->event_client)); priv->event_client = start_calendar_server (uri); g_free (uri); } static void url_requested_cb (GtkHTML *html, const gchar *url, GtkHTMLStream *handle, gpointer data) { unsigned char buffer[4096]; int len, fd; char *path; path = g_strdup_printf ("%s/%s", EVOLUTION_ICONSDIR, url); if ((fd = open (path, O_RDONLY)) == -1) { g_warning ("%s", g_strerror (errno)); goto cleanup; } while ((len = read (fd, buffer, 4096)) > 0) { gtk_html_write (html, handle, buffer, len); } if (len < 0) { /* check to see if we stopped because of an error */ gtk_html_end (html, handle, GTK_HTML_STREAM_ERROR); g_warning ("%s", g_strerror (errno)); goto cleanup; } /* done with no errors */ gtk_html_end (html, handle, GTK_HTML_STREAM_OK); close (fd); cleanup: g_free (path); } static gboolean object_requested_cb (GtkHTML *html, GtkHTMLEmbedded *eb, gpointer data) { EItipControl *itip = E_ITIP_CONTROL (data); EItipControlPrivate *priv; GtkWidget *button; CalComponentVType vtype; priv = itip->priv; vtype = cal_component_get_vtype (priv->comp); switch (vtype) { case CAL_COMPONENT_EVENT: button = evolution_folder_selector_button_new ( global_shell_client, _("Select Calendar Folder"), calendar_config_default_calendar_folder (), calendar_types); priv->event_client = start_default_server (FALSE); break; case CAL_COMPONENT_TODO: button = evolution_folder_selector_button_new ( global_shell_client, _("Select Tasks Folder"), calendar_config_default_tasks_folder (), tasks_types); priv->task_client = start_default_server (TRUE); break; default: button = NULL; } gtk_signal_connect (GTK_OBJECT (button), "selected", button_selected_cb, itip); gtk_container_add (GTK_CONTAINER (eb), button); gtk_widget_show (button); return TRUE; } static void ok_clicked_cb (GtkHTML *html, const gchar *method, const gchar *url, const gchar *encoding, gpointer data) { EItipControl *itip = E_ITIP_CONTROL (data); EItipControlPrivate *priv; gchar **fields; gboolean rsvp = FALSE, status = FALSE; int i; priv = itip->priv; fields = g_strsplit (encoding, "&", -1); for (i = 0; fields[i] != NULL; i++) { gchar **key_value; key_value = g_strsplit (fields[i], "=", 2); if (key_value[0] != NULL && !strcmp (key_value[0], "action")) { if (key_value[1] == NULL) break; switch (key_value[1][0]) { case 'U': update_item (itip); break; case 'A': status = change_status (priv->ical_comp, priv->my_address, ICAL_PARTSTAT_ACCEPTED); if (status) { cal_component_rescan (priv->comp); update_item (itip); } break; case 'T': status = change_status (priv->ical_comp, priv->my_address, ICAL_PARTSTAT_TENTATIVE); if (status) { cal_component_rescan (priv->comp); update_item (itip); } break; case 'D': status = change_status (priv->ical_comp, priv->my_address, ICAL_PARTSTAT_DECLINED); if (status) { cal_component_rescan (priv->comp); remove_item (itip); } break; case 'F': send_freebusy (itip); break; case 'R': update_attendee_status (itip); break; case 'S': send_item (itip); break; case 'C': remove_item (itip); break; } } if (key_value[0] != NULL && !strcmp (key_value[0], "rsvp")) if (*key_value[1] == '1') rsvp = TRUE; g_strfreev (key_value); } g_strfreev (fields); if (rsvp && status) { CalComponent *comp = NULL; CalComponentVType vtype; icalcomponent *ical_comp; icalproperty *prop; icalvalue *value; const char *attendee; GSList *l, *list = NULL; comp = cal_component_clone (priv->comp); if (comp == NULL) return; vtype = cal_component_get_vtype (comp); if (priv->my_address == NULL) find_my_address (itip, priv->ical_comp); g_assert (priv->my_address != NULL); ical_comp = cal_component_get_icalcomponent (comp); for (prop = icalcomponent_get_first_property (ical_comp, ICAL_ATTENDEE_PROPERTY); prop != NULL; prop = icalcomponent_get_next_property (ical_comp, ICAL_ATTENDEE_PROPERTY)) { char *text; value = icalproperty_get_value (prop); if (!value) continue; attendee = icalvalue_get_string (value); text = g_strdup (itip_strip_mailto (attendee)); text = g_strstrip (text); if (g_strcasecmp (priv->my_address, text)) list = g_slist_prepend (list, prop); g_free (text); } for (l = list; l; l = l->next) { prop = l->data; icalcomponent_remove_property (ical_comp, prop); icalproperty_free (prop); } g_slist_free (list); cal_component_rescan (comp); switch (vtype) { case CAL_COMPONENT_EVENT: itip_send_comp (CAL_COMPONENT_METHOD_REPLY, comp, priv->event_client, priv->top_level); break; case CAL_COMPONENT_TODO: itip_send_comp (CAL_COMPONENT_METHOD_REPLY, comp, priv->task_client, priv->top_level); break; default: itip_send_comp (CAL_COMPONENT_METHOD_REPLY, comp, NULL, NULL); } gtk_object_unref (GTK_OBJECT (comp)); } }