static void
icaltimezone_expand_vtimezone (icalcomponent *comp,
int end_year,
icalarray *changes)
{
icaltimezonechange change;
icalproperty *prop;
struct icaltimetype dtstart, occ;
struct icalrecurrencetype rrule;
icalrecur_iterator* rrule_iterator;
struct icaldatetimeperiodtype rdate;
int found_dtstart = 0, found_tzoffsetto = 0, found_tzoffsetfrom = 0;
int has_recurrence = 0;
/* First we check if it is a STANDARD or DAYLIGHT component, and
just return if it isn't. */
if (icalcomponent_isa (comp) == ICAL_XSTANDARD_COMPONENT)
change.is_daylight = 0;
else if (icalcomponent_isa (comp) == ICAL_XDAYLIGHT_COMPONENT)
change.is_daylight = 1;
else
return;
/* Step through each of the properties to find the DTSTART,
TZOFFSETFROM and TZOFFSETTO. We can't expand recurrences here
since we need these properties before we can do that. */
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
switch (icalproperty_isa (prop)) {
case ICAL_DTSTART_PROPERTY:
dtstart = icalproperty_get_dtstart (prop);
found_dtstart = 1;
break;
case ICAL_TZOFFSETTO_PROPERTY:
change.utc_offset = icalproperty_get_tzoffsetto (prop);
/*printf ("Found TZOFFSETTO: %i\n", change.utc_offset);*/
found_tzoffsetto = 1;
break;
case ICAL_TZOFFSETFROM_PROPERTY:
change.prev_utc_offset = icalproperty_get_tzoffsetfrom (prop);
/*printf ("Found TZOFFSETFROM: %i\n", change.prev_utc_offset);*/
found_tzoffsetfrom = 1;
break;
case ICAL_RDATE_PROPERTY:
case ICAL_RRULE_PROPERTY:
has_recurrence = 1;
break;
default:
/* Just ignore any other properties. */
break;
}
prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
}
/* If we didn't find a DTSTART, TZOFFSETTO and TZOFFSETFROM we have to
ignore the component. FIXME: Add an error property? */
if (!found_dtstart || !found_tzoffsetto || !found_tzoffsetfrom)
return;
#if 0
printf ("\n Expanding component DTSTART (Y/M/D): %i/%i/%i %i:%02i:%02i\n",
dtstart.year, dtstart.month, dtstart.day,
dtstart.hour, dtstart.minute, dtstart.second);
#endif
/* If the STANDARD/DAYLIGHT component has no recurrence data, we just add
a single change for the DTSTART. */
if (!has_recurrence) {
change.year = dtstart.year;
change.month = dtstart.month;
change.day = dtstart.day;
change.hour = dtstart.hour;
change.minute = dtstart.minute;
change.second = dtstart.second;
/* Convert to UTC. */
icaltimezone_adjust_change (&change, 0, 0, 0, -change.prev_utc_offset);
#if 0
printf (" Appending single DTSTART (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
/* Add the change to the array. */
icalarray_append (changes, &change);
return;
}
/* The component has recurrence data, so we expand that now. */
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
#if 0
printf ("Expanding property...\n");
#endif
switch (icalproperty_isa (prop)) {
case ICAL_RDATE_PROPERTY:
rdate = icalproperty_get_rdate (prop);
change.year = rdate.time.year;
change.month = rdate.time.month;
change.day = rdate.time.day;
/* RDATEs with a DATE value inherit the time from
the DTSTART. */
if (icaltime_is_date(rdate.time)) {
change.hour = dtstart.hour;
change.minute = dtstart.minute;
change.second = dtstart.second;
} else {
change.hour = rdate.time.hour;
change.minute = rdate.time.minute;
change.second = rdate.time.second;
/* The spec was a bit vague about whether RDATEs were in local
time or UTC so we support both to be safe. So if it is in
UTC we have to add the UTC offset to get a local time. */
if (!icaltime_is_utc(rdate.time))
icaltimezone_adjust_change (&change, 0, 0, 0,
-change.prev_utc_offset);
}
#if 0
printf (" Appending RDATE element (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
icalarray_append (changes, &change);
break;
case ICAL_RRULE_PROPERTY:
rrule = icalproperty_get_rrule (prop);
/* If the rrule UNTIL value is set and is in UTC, we convert it to
a local time, since the recurrence code has no way to convert
it itself. */
if (!icaltime_is_null_time (rrule.until) && rrule.until.is_utc) {
#if 0
printf (" Found RRULE UNTIL in UTC.\n");
#endif
/* To convert from UTC to a local time, we use the TZOFFSETFROM
since that is the offset from UTC that will be in effect
when each of the RRULE occurrences happens. */
icaltime_adjust (&rrule.until, 0, 0, 0,
change.prev_utc_offset);
rrule.until.is_utc = 0;
}
rrule_iterator = icalrecur_iterator_new (rrule, dtstart);
for (;;) {
occ = icalrecur_iterator_next (rrule_iterator);
if (occ.year > end_year || icaltime_is_null_time (occ))
break;
change.year = occ.year;
change.month = occ.month;
change.day = occ.day;
change.hour = occ.hour;
change.minute = occ.minute;
change.second = occ.second;
#if 0
printf (" Appending RRULE element (Y/M/D): %i/%02i/%02i %i:%02i:%02i\n",
change.year, change.month, change.day,
change.hour, change.minute, change.second);
#endif
icaltimezone_adjust_change (&change, 0, 0, 0,
-change.prev_utc_offset);
icalarray_append (changes, &change);
}
icalrecur_iterator_free (rrule_iterator);
break;
default:
break;
}
prop = icalcomponent_get_next_property (comp, ICAL_ANY_PROPERTY);
}
}
static void
e_cal_util_remove_instances_ex (icalcomponent *icalcomp,
struct icaltimetype rid,
ECalObjModType mod,
gboolean keep_rid,
gboolean can_add_exrule)
{
icalproperty *prop;
struct icaltimetype itt, recur;
struct icalrecurrencetype rule;
icalrecur_iterator *iter;
GSList *remove_props = NULL, *rrules = NULL, *link;
g_return_if_fail (icalcomp != NULL);
g_return_if_fail (mod != E_CAL_OBJ_MOD_ALL);
/* First remove RDATEs and EXDATEs in the indicated range. */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RDATE_PROPERTY)) {
struct icaldatetimeperiodtype period;
period = icalproperty_get_rdate (prop);
if (time_matches_rid (period.time, rid, mod) && (!keep_rid ||
icaltime_compare (period.time, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_EXDATE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_EXDATE_PROPERTY)) {
itt = icalproperty_get_exdate (prop);
if (time_matches_rid (itt, rid, mod) && (!keep_rid ||
icaltime_compare (itt, rid) != 0))
remove_props = g_slist_prepend (remove_props, prop);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
remove_props = NULL;
/* If we're only removing one instance, just add an EXDATE. */
if (mod == E_CAL_OBJ_MOD_THIS) {
prop = icalproperty_new_exdate (rid);
icalcomponent_add_property (icalcomp, prop);
return;
}
/* Otherwise, iterate through RRULEs */
/* FIXME: this may generate duplicate EXRULEs */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
rrules = g_slist_prepend (rrules, prop);
}
for (link = rrules; link; link = g_slist_next (link)) {
prop = link->data;
rule = icalproperty_get_rrule (prop);
iter = icalrecur_iterator_new (rule, rid);
recur = icalrecur_iterator_next (iter);
if (mod & E_CAL_OBJ_MOD_THIS_AND_FUTURE) {
/* Truncate the rule at rid. */
if (!icaltime_is_null_time (recur)) {
/* Use count if it was used */
if (rule.count > 0) {
gint occurrences_count = 0;
icalrecur_iterator *count_iter;
struct icaltimetype count_recur;
count_iter = icalrecur_iterator_new (rule, icalcomponent_get_dtstart (icalcomp));
while (count_recur = icalrecur_iterator_next (count_iter), !icaltime_is_null_time (count_recur) && occurrences_count < rule.count) {
if (icaltime_compare (count_recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (count_iter);
if (keep_rid && icaltime_compare (count_recur, rid) == 0)
occurrences_count++;
/* The caller should make sure that the remove will keep at least one instance */
g_warn_if_fail (occurrences_count > 0);
rule.count = occurrences_count;
} else {
if (keep_rid && icaltime_compare (recur, rid) == 0)
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
else
rule.until = rid;
icaltime_adjust (&rule.until, 0, 0, 0, -1);
}
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
} else {
/* (If recur == rid, skip to the next occurrence) */
if (!keep_rid && icaltime_compare (recur, rid) == 0)
recur = icalrecur_iterator_next (iter);
/* If there is a recurrence after rid, add
* an EXRULE to block instances up to rid.
* Otherwise, just remove the RRULE.
*/
if (!icaltime_is_null_time (recur)) {
if (can_add_exrule) {
rule.count = 0;
/* iCalendar says we should just use rid
* here, but Outlook/Exchange handle
* UNTIL incorrectly.
*/
if (keep_rid && icaltime_compare (recur, rid) == 0) {
struct icaldurationtype duration = icalcomponent_get_duration (icalcomp);
duration.is_neg = !duration.is_neg;
rule.until = icaltime_add (rid, duration);
} else
rule.until = icaltime_add (rid, icalcomponent_get_duration (icalcomp));
prop = icalproperty_new_exrule (rule);
icalcomponent_add_property (icalcomp, prop);
}
} else {
remove_props = g_slist_prepend (remove_props, prop);
}
}
icalrecur_iterator_free (iter);
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
g_slist_free (rrules);
}
/** Gets the TZNAMEs used for the last STANDARD & DAYLIGHT components
in a VTIMEZONE. If both STANDARD and DAYLIGHT components use the
same TZNAME, it returns that. If they use different TZNAMEs, it
formats them like "EST/EDT". The returned string should be freed by
the caller. */
static char*
icaltimezone_get_tznames_from_vtimezone (icalcomponent *component)
{
icalcomponent *comp;
icalcomponent_kind type;
icalproperty *prop;
struct icaltimetype dtstart;
struct icaldatetimeperiodtype rdate;
const char *current_tzname;
const char *standard_tzname = NULL, *daylight_tzname = NULL;
struct icaltimetype standard_max_date, daylight_max_date;
struct icaltimetype current_max_date;
standard_max_date = icaltime_null_time();
daylight_max_date = icaltime_null_time();
/* Step through the STANDARD & DAYLIGHT subcomponents. */
comp = icalcomponent_get_first_component (component, ICAL_ANY_COMPONENT);
while (comp) {
type = icalcomponent_isa (comp);
if (type == ICAL_XSTANDARD_COMPONENT
|| type == ICAL_XDAYLIGHT_COMPONENT) {
current_max_date = icaltime_null_time ();
current_tzname = NULL;
/* Step through the properties. We want to find the TZNAME, and
the largest DTSTART or RDATE. */
prop = icalcomponent_get_first_property (comp, ICAL_ANY_PROPERTY);
while (prop) {
switch (icalproperty_isa (prop)) {
case ICAL_TZNAME_PROPERTY:
current_tzname = icalproperty_get_tzname (prop);
break;
case ICAL_DTSTART_PROPERTY:
dtstart = icalproperty_get_dtstart (prop);
if (icaltime_compare (dtstart, current_max_date) > 0)
current_max_date = dtstart;
break;
case ICAL_RDATE_PROPERTY:
rdate = icalproperty_get_rdate (prop);
if (icaltime_compare (rdate.time, current_max_date) > 0)
current_max_date = rdate.time;
break;
default:
break;
}
prop = icalcomponent_get_next_property (comp,
ICAL_ANY_PROPERTY);
}
if (current_tzname) {
if (type == ICAL_XSTANDARD_COMPONENT) {
if (!standard_tzname
|| icaltime_compare (current_max_date,
standard_max_date) > 0) {
standard_max_date = current_max_date;
standard_tzname = current_tzname;
}
} else {
if (!daylight_tzname
|| icaltime_compare (current_max_date,
daylight_max_date) > 0) {
daylight_max_date = current_max_date;
daylight_tzname = current_tzname;
}
}
}
}
comp = icalcomponent_get_next_component (component,
ICAL_ANY_COMPONENT);
}
/* Outlook (2000) places "Standard Time" and "Daylight Time" in the TZNAME
strings, which is totally useless. So we return NULL in that case. */
if (standard_tzname && !strcmp (standard_tzname, "Standard Time"))
return NULL;
/* If both standard and daylight TZNAMEs were found, if they are the same
we return just one, else we format them like "EST/EDT". */
if (standard_tzname && daylight_tzname) {
unsigned int standard_len, daylight_len;
char *tznames;
if (!strcmp (standard_tzname, daylight_tzname))
return strdup (standard_tzname);
standard_len = strlen (standard_tzname);
daylight_len = strlen (daylight_tzname);
tznames = malloc (standard_len + daylight_len + 2);
strcpy (tznames, standard_tzname);
tznames[standard_len] = '/';
strcpy (tznames + standard_len + 1, daylight_tzname);
return tznames;
} else {
const char *tznames;
/* If either of the TZNAMEs was found just return that, else NULL. */
tznames = standard_tzname ? standard_tzname : daylight_tzname;
return tznames ? strdup (tznames) : NULL;
}
}
