aboutsummaryrefslogtreecommitdiffstats
path: root/calendar
diff options
context:
space:
mode:
Diffstat (limited to 'calendar')
-rw-r--r--calendar/icalendar.c722
1 files changed, 722 insertions, 0 deletions
diff --git a/calendar/icalendar.c b/calendar/icalendar.c
new file mode 100644
index 0000000000..43c1b46016
--- /dev/null
+++ b/calendar/icalendar.c
@@ -0,0 +1,722 @@
+/*
+ * icalendar server for gnomecal
+ *
+ * This module interfaces between libical and the gnomecal internal
+ * representation
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ * Authors:
+ * Russell Steinthal (rms39@columbia.edu)
+ *
+ */
+
+#include <gnome.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include "ical.h"
+#include "calobj.h"
+#include "calendar.h"
+
+void icalendar_calendar_load (Calendar* cal, char* fname);
+static icalcomponent* icalendar_parse_file (char* fname);
+static time_t icaltime_to_timet (struct icaltimetype* i);
+static CalendarAlarm* parse_alarm (icalproperty *prop);
+static iCalPerson* parse_person (icalproperty *prop, gchar *value);
+static iCalRelation* parse_related (icalproperty *prop);
+
+/* Duplicate a string without memory leaks */
+static gchar* copy_str (gchar** store, gchar* src)
+{
+ if (*store)
+ g_free (*store);
+ return (*store = g_strdup (src));
+}
+
+static GList*
+copy_to_list (GList** store, gchar* src)
+{
+ *store = g_list_prepend (*store, g_strdup (src));
+ return *store;
+}
+
+/* eh?
+ static icalcomponent*
+ ical_object_to_icalcomponent (iCalObject* ical)
+ {
+ icalcomponent *comp;
+*/
+
+static iCalObject *
+ical_object_create_from_icalcomponent (icalcomponent* comp)
+{
+ iCalObject *ical = NULL;
+ iCalPerson *person;
+ icalcomponent *subcomp;
+ icalproperty *prop;
+ icalparameter *param;
+ struct icaltimetype ictime;
+ time_t *pt;
+ CalendarAlarm *alarm = NULL;
+ icalcomponent_kind compType;
+ struct icalgeotype geo;
+ struct icalperiodtype period;
+
+ gboolean root = FALSE;
+ gboolean attachment = FALSE;
+
+ char *tmpStr; /* this is a library-owned string */
+
+ ical = g_new0 (iCalObject, 1);
+
+ compType = icalcomponent_isa (comp);
+
+ switch (compType) {
+ case ICAL_XROOT_COMPONENT:
+ root = TRUE;
+ break;
+ case ICAL_XATTACH_COMPONENT:
+ attachment = TRUE;
+ break;
+ case ICAL_VEVENT_COMPONENT:
+ ical->type = ICAL_EVENT;
+ break;
+ case ICAL_VTODO_COMPONENT:
+ ical->type = ICAL_TODO;
+ break;
+ case ICAL_VJOURNAL_COMPONENT:
+ ical->type = ICAL_JOURNAL;
+ break;
+ case ICAL_VCALENDAR_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_VFREEBUSY_COMPONENT:
+ ical->type = ICAL_FBREQUEST;
+ /* NOTE: This is not conclusive- you need to analyze
+ properties to determine whether this is an
+ FBREQUEST or an FBREPLY */
+ break;
+ case ICAL_VTIMEZONE_COMPONENT:
+ ical->type = ICAL_TIMEZONE;
+ break;
+ case ICAL_VALARM_COMPONENT:
+ case ICAL_XAUDIOALARM_COMPONENT:
+ case ICAL_XDISPLAYALARM_COMPONENT:
+ case ICAL_XEMAILALARM_COMPONENT:
+ case ICAL_XPROCEDUREALARM_COMPONENT:
+ /* this should not be reached, since this loop should
+ only be processing first level components */
+ break;
+ case ICAL_XSTANDARD_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_XDAYLIGHT_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_X_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_VSCHEDULE_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_XLICINVALID_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ case ICAL_NO_COMPONENT:
+ case ICAL_ANY_COMPONENT:
+ /* should not occur */
+ break;
+ case ICAL_VQUERY_COMPONENT:
+ case ICAL_VCAR_COMPONENT:
+ case ICAL_VCOMMAND_COMPONENT:
+ /* FIXME: what does this mean? */
+ break;
+ }
+
+ prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
+ while (prop) {
+ switch (icalproperty_isa (prop)) {
+ case ICAL_CALSCALE_PROPERTY:
+ if (g_strcasecmp (icalproperty_get_calscale (prop),
+ "GREGORIAN"))
+ g_warning ("Unknown calendar format.");
+ break;
+ case ICAL_METHOD_PROPERTY:
+ /* FIXME: implement something here */
+ break;
+ case ICAL_ATTACH_PROPERTY:
+ /* FIXME: not yet implemented */
+ break;
+ case ICAL_CATEGORIES_PROPERTY:
+ copy_to_list (&ical->categories,
+ icalproperty_get_categories (prop));
+ break;
+ case ICAL_CLASS_PROPERTY:
+ copy_str (&ical->class, icalproperty_get_class (prop));
+ break;
+ case ICAL_COMMENT_PROPERTY:
+ tmpStr = icalproperty_get_comment (prop);
+ tmpStr = g_strconcat (icalproperty_get_comment (prop),
+ ical->comment,
+ NULL);
+ if (ical->comment)
+ g_free (ical->comment);
+ ical->comment = tmpStr;
+ break;
+ case ICAL_DESCRIPTION_PROPERTY:
+ copy_str (&ical->desc,
+ icalproperty_get_description (prop));
+ break;
+ case ICAL_GEO_PROPERTY:
+ geo = icalproperty_get_geo (prop);
+ ical->geo.latitude = geo.lat;
+ ical->geo.longitude = geo.lon;
+ ical->geo.valid = TRUE;
+ break;
+ case ICAL_LOCATION_PROPERTY:
+ copy_str (&ical->location,
+ icalproperty_get_location (prop));
+ break;
+ case ICAL_PERCENTCOMPLETE_PROPERTY:
+ ical->percent = icalproperty_get_percentcomplete (prop);
+ break;
+ case ICAL_PRIORITY_PROPERTY:
+ ical->priority = icalproperty_get_priority (prop);
+ if (ical->priority < 0 || ical->priority > 9)
+ g_warning ("Priority out-of-range (see RFC2445)");
+ break;
+ case ICAL_RESOURCES_PROPERTY:
+ copy_to_list (&ical->resources,
+ icalproperty_get_resources (prop));
+ break;
+ case ICAL_STATUS_PROPERTY:
+ copy_str (&ical->status,
+ icalproperty_get_status (prop));
+ break;
+ case ICAL_SUMMARY_PROPERTY:
+ copy_str (&ical->summary,
+ icalproperty_get_summary (prop));
+ break;
+ case ICAL_COMPLETED_PROPERTY:
+ ictime = icalproperty_get_completed (prop);
+ ical->completed = icaltime_to_timet (&ictime);
+ break;
+ case ICAL_DTEND_PROPERTY:
+ ictime = icalproperty_get_dtend (prop);
+ ical->dtend = icaltime_to_timet (&ictime);
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_VALUE_PARAMETER);
+ ical->date_only = (icalparameter_get_value (param) ==
+ ICAL_VALUE_DATE);
+ /* FIXME: We should handle timezone specifiers */
+ break;
+ case ICAL_DUE_PROPERTY:
+ ictime = icalproperty_get_due (prop);
+ ical->dtend = icaltime_to_timet (&ictime);
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_VALUE_PARAMETER);
+ ical->date_only = (icalparameter_get_value (param) ==
+ ICAL_VALUE_DATE);
+ /* FIXME: We should handle timezone specifiers */
+ break;
+ case ICAL_DTSTART_PROPERTY:
+ ictime = icalproperty_get_dtstart (prop);
+ ical->dtstart = icaltime_to_timet (&ictime);
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_VALUE_PARAMETER);
+ ical->date_only = (icalparameter_get_value (param) ==
+ ICAL_VALUE_DATE);
+ /* FIXME: We should handle timezone specifiers */
+ break;
+ case ICAL_DURATION_PROPERTY:
+ /* FIXME: I don't see the necessary libical function */
+ break;
+ case ICAL_FREEBUSY_PROPERTY:
+ period = icalproperty_get_freebusy (prop);
+ ical->dtstart = icaltime_to_timet (&(period.start));
+ /* FIXME: period.end is specified as being relative to start, so
+this may not be correct */
+ ical->dtend = icaltime_to_timet (&(period.end));
+ break;
+ case ICAL_TRANSP_PROPERTY:
+ tmpStr = icalproperty_get_transp (prop);
+ /* do not i18n the following string constant! */
+ if (!g_strcasecmp (tmpStr, "TRANSPARENT"))
+ ical->transp = ICAL_TRANSPARENT;
+ else
+ ical->transp = ICAL_OPAQUE;
+ break;
+ case ICAL_TZID_PROPERTY:
+ case ICAL_TZNAME_PROPERTY:
+ case ICAL_TZOFFSETFROM_PROPERTY:
+ case ICAL_TZOFFSETTO_PROPERTY:
+ case ICAL_TZURL_PROPERTY:
+ /* no implementation for now */
+ break;
+ case ICAL_ATTENDEE_PROPERTY:
+ tmpStr = icalproperty_get_attendee (prop);
+ person = parse_person (prop, tmpStr);
+ ical->attendee = g_list_prepend (ical->attendee,
+ person);
+ break;
+ case ICAL_CONTACT_PROPERTY:
+ tmpStr = icalproperty_get_contact (prop);
+ person = parse_person (prop, tmpStr);
+ ical->contact = g_list_prepend (ical->contact, person);
+ break;
+ case ICAL_ORGANIZER_PROPERTY:
+ tmpStr = icalproperty_get_organizer (prop);
+ person = parse_person (prop, tmpStr);
+ if (ical->organizer)
+ g_free (ical->organizer);
+ ical->organizer = person;
+ break;
+ case ICAL_RECURRENCEID_PROPERTY:
+ ictime = icalproperty_get_recurrenceid (prop);
+ ical->recurid = icaltime_to_timet (&ictime);
+ /* FIXME: Range parameter not implemented */
+ break;
+ case ICAL_RELATEDTO_PROPERTY:
+ ical->related = g_list_prepend (ical->related,
+ parse_related (prop));
+ break;
+ case ICAL_URL_PROPERTY:
+ copy_str (&ical->url,
+ icalproperty_get_url (prop));
+ break;
+ case ICAL_UID_PROPERTY:
+ copy_str (&ical->uid,
+ icalproperty_get_uid (prop));
+ break;
+ case ICAL_EXDATE_PROPERTY:
+ /* FIXME: This does not appear to parse
+ multiple exdate values in one property, as
+ allowed by the RFC; needs a libical fix */
+ ictime = icalproperty_get_exdate (prop);
+ pt = g_new0 (time_t, 1);
+ *pt = icaltime_to_timet (&ictime);
+ ical->exdate = g_list_prepend (ical->exdate, pt);
+ break;
+ case ICAL_EXRULE_PROPERTY:
+ case ICAL_RDATE_PROPERTY:
+ case ICAL_RRULE_PROPERTY:
+ /* FIXME: need recursion processing */
+ break;
+ case ICAL_ACTION_PROPERTY:
+ case ICAL_REPEAT_PROPERTY:
+ case ICAL_TRIGGER_PROPERTY:
+ /* should only occur in VALARM's, handled below */
+ g_assert_not_reached();
+ break;
+ case ICAL_CREATED_PROPERTY:
+ ictime = icalproperty_get_created (prop);
+ ical->created = icaltime_to_timet (&ictime);
+ break;
+ case ICAL_DTSTAMP_PROPERTY:
+ ictime = icalproperty_get_dtstamp (prop);
+ ical->dtstamp = icaltime_to_timet (&ictime);
+ break;
+ case ICAL_LASTMODIFIED_PROPERTY:
+ ictime = icalproperty_get_lastmodified (prop);
+ ical->last_mod = icaltime_to_timet (&ictime);
+ break;
+ case ICAL_SEQUENCE_PROPERTY:
+ ical->seq = icalproperty_get_sequence (prop);
+ break;
+ case ICAL_REQUESTSTATUS_PROPERTY:
+ copy_str (&ical->rstatus,
+ icalproperty_get_requeststatus (prop));
+ break;
+ case ICAL_X_PROPERTY:
+ g_warning ("Unsupported X-property: %s",
+ icalproperty_as_ical_string (prop));
+ break;
+ case ICAL_XLICERROR_PROPERTY:
+ g_warning ("Unsupported property: %s",
+ icalproperty_get_xlicerror (prop));
+ break;
+ case ICAL_PRODID_PROPERTY:
+ case ICAL_VERSION_PROPERTY:
+ /* nothing to do for this property */
+ break;
+ default:
+ g_warning ("Unsupported property: %s", icalproperty_as_ical_string
+(prop));
+ break;
+
+ }
+
+ prop = icalcomponent_get_next_property (comp,
+ ICAL_ANY_PROPERTY);
+ }
+
+ /* now parse subcomponents --- should only be VALARM's */
+ subcomp = icalcomponent_get_first_component (comp,
+ ICAL_ANY_COMPONENT);
+ while (subcomp) {
+ compType = icalcomponent_isa (subcomp);
+ switch (compType) {
+ case ICAL_VALARM_COMPONENT:
+ alarm = parse_alarm (subcomp);
+ if (alarm)
+ ical->alarms = g_list_prepend (ical->alarms,
+ alarm);
+ break;
+ default:
+ g_warning ("Only nested VALARM components are supported.");
+ }
+
+ subcomp = icalcomponent_get_next_component (comp,
+ ICAL_ANY_COMPONENT);
+ }
+
+ return ical;
+}
+
+void
+icalendar_calendar_load (Calendar* cal, char* fname)
+{
+ icalcomponent *comp;
+ icalcomponent *subcomp;
+ iCalObject *ical;
+
+ comp = icalendar_parse_file (fname);
+ subcomp = icalcomponent_get_first_component (comp,
+ ICAL_ANY_COMPONENT);
+ while (subcomp) {
+ ical = ical_object_create_from_icalcomponent (subcomp);
+ if (ical->type != ICAL_EVENT &&
+ ical->type != ICAL_TODO &&
+ ical->type != ICAL_JOURNAL) {
+ g_warning ("Skipping unsupported iCalendar component.");
+ } else
+ calendar_add_object (cal, ical);
+ subcomp = icalcomponent_get_next_component (comp,
+ ICAL_ANY_COMPONENT);
+ }
+}
+
+static icalcomponent*
+icalendar_parse_file (char* fname)
+{
+ FILE* fp;
+ icalcomponent* comp = NULL;
+ gchar* str;
+ struct stat st;
+ int n;
+
+ fp = fopen (fname, "r");
+ if (!fp) {
+ g_warning ("Cannot open open calendar file.");
+ return NULL;
+ }
+
+ stat (fname, &st);
+
+ str = g_malloc (st.st_size + 2);
+
+ n = fread ((gchar*) str, 1, st.st_size, fp);
+ if (n != st.st_size) {
+ g_warning ("Read error.");
+ }
+ str[n] = '\0';
+
+ fclose (fp);
+
+ comp = icalparser_parse_string (str);
+ g_free (str);
+
+ return comp;
+}
+
+static time_t icaltime_to_timet (struct icaltimetype* i)
+{
+ extern long timezone;
+ struct tm t;
+ time_t ret;
+
+ t.tm_year = i->year - 1900;
+ t.tm_mon = i->month - 1;
+ t.tm_mday = i->day;
+ if (!i->is_date) {
+ t.tm_hour = i->hour;
+ t.tm_min = i->minute;
+ t.tm_sec = i->second;
+ } else {
+ t.tm_hour = 0;
+ t.tm_min = 0;
+ t.tm_sec = 0;
+ }
+
+ ret = mktime(&t);
+
+ return ret - (i->is_utc ? timezone : 0);
+}
+
+static iCalPerson*
+parse_person (icalproperty* prop, gchar* value)
+{
+ icalparameter* param;
+ icalparameter_role role;
+ icalparameter_partstat partstat;
+ icalparameter_cutype cutype;
+
+ iCalPerson* ret;
+
+ ret = g_new0 (iCalPerson, 1);
+
+ ret->addr = g_strdup (value);
+
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_CN_PARAMETER);
+ ret->name = g_strdup (icalparameter_get_cn (param));
+
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_ROLE_PARAMETER);
+ if (param) {
+ role = icalparameter_get_role (param);
+ switch (role) {
+ case ICAL_ROLE_CHAIR:
+ ret->role = g_strdup ("CHAIR");
+ break;
+ case ICAL_ROLE_REQPARTICIPANT:
+ ret->role = g_strdup ("REQPARTICIPANT");
+ break;
+ case ICAL_ROLE_OPTPARTICIPANT:
+ ret->role = g_strdup ("OPTPARTICIPANT");
+ break;
+ case ICAL_ROLE_NONPARTICIPANT:
+ ret->role = g_strdup ("NONPARTICIPANT");
+ break;
+ case ICAL_ROLE_XNAME:
+ default:
+ ret->role = g_strdup ("UNKNOWN");
+ break;
+ }
+ } else
+ ret->role = g_strdup ("REQPARTICIPANT");
+
+ param = icalproperty_get_first_parameter (prop, ICAL_PARTSTAT_PARAMETER);
+ if (param) {
+ partstat = icalparameter_get_partstat (param);
+ switch (partstat) {
+ case ICAL_PARTSTAT_NEEDSACTION:
+ ret->partstat = g_strdup ("NEEDSACTION");
+ break;
+ case ICAL_PARTSTAT_ACCEPTED:
+ ret->partstat = g_strdup ("ACCEPTED");
+ break;
+ case ICAL_PARTSTAT_DECLINED:
+ ret->partstat = g_strdup ("DECLINED");
+ break;
+ case ICAL_PARTSTAT_TENTATIVE:
+ ret->partstat = g_strdup ("TENTATIVE");
+ break;
+ case ICAL_PARTSTAT_DELEGATED:
+ ret->partstat = g_strdup ("DELEGATED");
+ break;
+ case ICAL_PARTSTAT_COMPLETED:
+ ret->partstat = g_strdup ("COMPLETED");
+ break;
+ case ICAL_PARTSTAT_INPROCESS:
+ ret->partstat = g_strdup ("INPROCESS");
+ break;
+ case ICAL_PARTSTAT_XNAME:
+ ret->partstat = g_strdup (icalparameter_get_xvalue (param));
+ break;
+ default:
+ ret->partstat = g_strdup ("UNKNOWN");
+ break;
+ }
+ } else
+ ret->partstat = g_strdup ("NEEDSACTION");
+
+ param = icalproperty_get_first_parameter (prop, ICAL_RSVP_PARAMETER);
+ if (param)
+ ret->rsvp = icalparameter_get_rsvp (param);
+ else
+ ret->rsvp = FALSE;
+
+ param = icalproperty_get_first_parameter (prop, ICAL_CUTYPE_PARAMETER
+);
+ if (param) {
+ cutype = icalparameter_get_cutype (param);
+ switch (cutype) {
+ case ICAL_CUTYPE_INDIVIDUAL:
+ ret->cutype = g_strdup ("INDIVIDUAL");
+ break;
+ case ICAL_CUTYPE_GROUP:
+ ret->cutype = g_strdup ("GROUP");
+ break;
+ case ICAL_CUTYPE_RESOURCE:
+ ret->cutype = g_strdup ("RESOURCE");
+ break;
+ case ICAL_CUTYPE_ROOM:
+ ret->cutype = g_strdup ("ROOM");
+ break;
+ case ICAL_CUTYPE_UNKNOWN:
+ case ICAL_CUTYPE_XNAME:
+ default:
+ ret->cutype = g_strdup ("UNKNOWN");
+ break;
+ }
+ } else
+ ret->cutype = g_strdup ("INDIVIDUAL");
+
+ param = icalproperty_get_first_parameter (prop, ICAL_MEMBER_PARAMETER
+);
+ while (param) {
+ copy_to_list (&ret->member, icalparameter_get_member (param));
+ param = icalproperty_get_next_parameter (prop,
+ ICAL_MEMBER_PARAMETER);
+ }
+
+ param = icalproperty_get_first_parameter (prop, ICAL_DELEGATEDTO_PARAMETER);
+ while (param) {
+ copy_to_list (&ret->deleg_to,
+ icalparameter_get_delegatedto (param));
+ param = icalproperty_get_next_parameter (prop,
+ ICAL_DELEGATEDTO_PARAMETER);
+ }
+
+ param = icalproperty_get_first_parameter (prop, ICAL_DELEGATEDFROM_PARAMETER);
+ while (param) {
+ copy_to_list (&ret->deleg_from,
+ icalparameter_get_delegatedfrom (param));
+ param = icalproperty_get_next_parameter (prop,
+ ICAL_DELEGATEDFROM_PARAMETER);
+ }
+
+ param = icalproperty_get_first_parameter (prop, ICAL_SENTBY_PARAMETER
+);
+ copy_str (&ret->sent_by,
+ icalparameter_get_sentby (param));
+
+ param = icalproperty_get_first_parameter (prop, ICAL_DIR_PARAMETER);
+ while (param) {
+ copy_to_list (&ret->deleg_to,
+ icalparameter_get_delegatedto (param));
+ param = icalproperty_get_next_parameter (prop,
+ ICAL_DIR_PARAMETER);
+ }
+
+ return ret;
+}
+
+static iCalRelation*
+parse_related (icalproperty* prop)
+{
+ iCalRelation* rel;
+ icalparameter* param;
+ icalparameter_reltype type;
+
+ rel = g_new0 (iCalRelation, 1);
+ rel->uid = g_strdup (icalproperty_get_relatedto (prop));
+
+ param = icalproperty_get_first_parameter (prop,
+ ICAL_RELTYPE_PARAMETER);
+ if (param) {
+ type = icalparameter_get_reltype (param);
+ switch (type) {
+ case ICAL_RELTYPE_PARENT:
+ rel->reltype = g_strdup ("PARENT");
+ break;
+ case ICAL_RELTYPE_CHILD:
+ rel->reltype = g_strdup ("CHILD");
+ break;
+ case ICAL_RELTYPE_SIBLING:
+ rel->reltype = g_strdup ("SIBLING");
+ break;
+ case ICAL_RELTYPE_XNAME:
+ rel->reltype = g_strdup (icalparameter_get_xvalue (param));
+ break;
+ default:
+ rel->reltype = g_strdup ("UNKNOWN");
+ break;
+ }
+ } else
+ rel->reltype = g_strdup ("PARENT");
+
+ return rel;
+}
+
+#ifdef TEST
+
+int main(int argc, char* argv[])
+{
+ icalcomponent* comp;
+ comp = icalendar_parse_file (argv[1]);
+ printf ("%s\n", icalcomponent_as_ical_string (comp));
+ return 0;
+}
+
+#endif
+
+
+static CalendarAlarm*
+parse_alarm (icalcomponent* comp)
+{
+ CalendarAlarm *alarm;
+ icalproperty *prop;
+ char *tmpStr;
+ struct icaldurationtype dur;
+ struct icalattachtype attach;
+
+ g_return_val_if_fail (comp != NULL, NULL);
+
+ alarm = g_new0 (CalendarAlarm, 1);
+
+ prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
+ while (prop) {
+ switch (icalproperty_isa (prop)) {
+ case ICAL_ACTION_PROPERTY:
+ tmpStr = icalproperty_get_action (prop);
+ if (!g_strcasecmp (tmpStr, "AUDIO"))
+ alarm->type = ALARM_AUDIO;
+ else if (!g_strcasecmp (tmpStr, "DISPLAY"))
+ alarm->type = ALARM_DISPLAY;
+ else if (!g_strcasecmp (tmpStr, "EMAIL"))
+ alarm->type = ALARM_MAIL;
+ else if (!g_strcasecmp (tmpStr, "PROCEDURE"))
+ alarm->type = ALARM_PROGRAM;
+ else
+ g_warning ("Unsupported alarm type!");
+ break;
+ case ICAL_TRIGGER_PROPERTY:
+ /* FIXME: waiting on proper libical support */
+ break;
+ case ICAL_REPEAT_PROPERTY:
+ alarm->snooze_repeat = icalproperty_get_repeat (prop);
+ break;
+ case ICAL_DURATION_PROPERTY:
+ dur = icalproperty_get_duration (prop);
+ alarm->snooze_secs = icaldurationtype_as_timet (dur);
+ break;
+ case ICAL_ATTACH_PROPERTY:
+ attach = icalproperty_get_attach (prop);
+ copy_str (&alarm->attach,
+ icalattachtype_get_url (&attach));
+ break;
+ case ICAL_DESCRIPTION_PROPERTY:
+ copy_str (&alarm->desc,
+ icalproperty_get_description (prop));
+ break;
+ case ICAL_SUMMARY_PROPERTY:
+ copy_str (&alarm->summary,
+ icalproperty_get_summary (prop));
+ break;
+ case ICAL_ATTENDEE_PROPERTY:
+ copy_str (&alarm->attendee,
+ icalproperty_get_attendee (prop));
+ break;
+ default:
+ g_warning ("Unsupported alarm property: %s",
+ icalproperty_as_ical_string (prop));
+ break;
+ }
+
+ prop = icalcomponent_get_next_property (comp,
+ ICAL_ANY_PROPERTY);
+ }
+
+ return alarm;
+}