static void
alarm_to_repeat_widgets (Dialog *dialog, ECalComponentAlarm *alarm)
{
ECalComponentAlarmRepeat repeat;
e_cal_component_alarm_get_repeat (dialog->alarm, &repeat);
if ( repeat.repetitions ) {
e_dialog_toggle_set (dialog->repeat_toggle, TRUE);
e_dialog_spin_set (dialog->repeat_quantity, repeat.repetitions);
} else
return;
if ( repeat.duration.minutes ) {
e_dialog_option_menu_set (dialog->repeat_unit, DUR_MINUTES, duration_units_map);
e_dialog_spin_set (dialog->repeat_value, repeat.duration.minutes);
}
if ( repeat.duration.hours ) {
e_dialog_option_menu_set (dialog->repeat_unit, DUR_HOURS, duration_units_map);
e_dialog_spin_set (dialog->repeat_value, repeat.duration.hours);
}
if ( repeat.duration.days ) {
e_dialog_option_menu_set (dialog->repeat_unit, DUR_DAYS, duration_units_map);
e_dialog_spin_set (dialog->repeat_value, repeat.duration.days);
}
}
static void
alarm_to_repeat_widgets (Dialog *dialog,
ECalComponentAlarm *alarm)
{
ECalComponentAlarmRepeat repeat;
e_cal_component_alarm_get_repeat (dialog->alarm, &repeat);
if (repeat.repetitions) {
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (dialog->repeat_toggle), TRUE);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->repeat_quantity),
repeat.repetitions);
} else
return;
if (repeat.duration.minutes) {
e_dialog_combo_box_set (dialog->repeat_unit_combo, DUR_MINUTES, duration_units_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->repeat_value),
repeat.duration.minutes);
}
if (repeat.duration.hours) {
e_dialog_combo_box_set (dialog->repeat_unit_combo, DUR_HOURS, duration_units_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->repeat_value),
repeat.duration.hours);
}
if (repeat.duration.days) {
e_dialog_combo_box_set (dialog->repeat_unit_combo, DUR_DAYS, duration_units_map);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->repeat_value),
repeat.duration.days);
}
}
/* Generates the absolute triggers for a component */
static void
generate_absolute_triggers (ECalComponent *comp,
struct alarm_occurrence_data *aod,
ECalRecurResolveTimezoneFn resolve_tzid,
gpointer user_data,
icaltimezone *default_timezone)
{
GList *l;
ECalComponentDateTime dt_start, dt_end;
e_cal_component_get_dtstart (comp, &dt_start);
e_cal_component_get_dtend (comp, &dt_end);
for (l = aod->alarm_uids; l; l = l->next) {
const gchar *auid;
ECalComponentAlarm *alarm;
ECalComponentAlarmAction action;
ECalComponentAlarmRepeat repeat;
ECalComponentAlarmTrigger trigger;
time_t abs_time;
time_t occur_start, occur_end;
icaltimezone *zone;
gint i;
auid = l->data;
alarm = e_cal_component_get_alarm (comp, auid);
g_return_if_fail (alarm != NULL);
e_cal_component_alarm_get_action (alarm, &action);
e_cal_component_alarm_get_trigger (alarm, &trigger);
e_cal_component_alarm_get_repeat (alarm, &repeat);
e_cal_component_alarm_free (alarm);
for (i = 0; aod->omit[i] != -1; i++) {
if (aod->omit[i] == action)
break;
}
if (aod->omit[i] != -1)
continue;
if (trigger.type != E_CAL_COMPONENT_ALARM_TRIGGER_ABSOLUTE)
continue;
/* Absolute triggers are always in UTC;
* see RFC 2445 section 4.8.6.3 */
zone = icaltimezone_get_utc_timezone ();
abs_time = icaltime_as_timet_with_zone (trigger.u.abs_time, zone);
/* No particular occurrence, so just use the times from the
* component */
if (dt_start.value) {
if (dt_start.tzid && !dt_start.value->is_date)
zone = (* resolve_tzid) (dt_start.tzid, user_data);
else
zone = default_timezone;
occur_start = icaltime_as_timet_with_zone (
*dt_start.value, zone);
} else
occur_start = -1;
if (dt_end.value) {
if (dt_end.tzid && !dt_end.value->is_date)
zone = (* resolve_tzid) (dt_end.tzid, user_data);
else
zone = default_timezone;
occur_end = icaltime_as_timet_with_zone (*dt_end.value, zone);
} else
occur_end = -1;
/* Add repeating alarms */
if (repeat.repetitions != 0) {
gint i;
time_t repeat_time;
repeat_time = icaldurationtype_as_int (repeat.duration);
for (i = 0; i < repeat.repetitions; i++) {
time_t t;
t = abs_time + (i + 1) * repeat_time;
if (t >= aod->start && t < aod->end)
add_trigger (
aod, auid, t,
occur_start, occur_end);
}
}
/* Add the trigger itself */
if (abs_time >= aod->start && abs_time < aod->end)
add_trigger (aod, auid, abs_time, occur_start, occur_end);
}
e_cal_component_free_datetime (&dt_start);
e_cal_component_free_datetime (&dt_end);
}
/* Callback used from cal_recur_generate_instances(); generates triggers for all
* of a component's RELATIVE alarms.
*/
static gboolean
add_alarm_occurrences_cb (ECalComponent *comp,
time_t start,
time_t end,
gpointer data)
{
struct alarm_occurrence_data *aod;
GList *l;
aod = data;
for (l = aod->alarm_uids; l; l = l->next) {
const gchar *auid;
ECalComponentAlarm *alarm;
ECalComponentAlarmAction action;
ECalComponentAlarmTrigger trigger;
ECalComponentAlarmRepeat repeat;
struct icaldurationtype *dur;
time_t dur_time;
time_t occur_time, trigger_time;
gint i;
auid = l->data;
alarm = e_cal_component_get_alarm (comp, auid);
g_return_val_if_fail (alarm != NULL, FALSE);
e_cal_component_alarm_get_action (alarm, &action);
e_cal_component_alarm_get_trigger (alarm, &trigger);
e_cal_component_alarm_get_repeat (alarm, &repeat);
e_cal_component_alarm_free (alarm);
for (i = 0; aod->omit[i] != -1; i++) {
if (aod->omit[i] == action)
break;
}
if (aod->omit[i] != -1)
continue;
if (trigger.type != E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START
&& trigger.type != E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_END)
continue;
dur = &trigger.u.rel_duration;
dur_time = icaldurationtype_as_int (*dur);
if (trigger.type == E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START)
occur_time = start;
else
occur_time = end;
/* If dur->is_neg is true then dur_time will already be
* negative. So we do not need to test for dur->is_neg here; we
* can simply add the dur_time value to the occur_time and get
* the correct result.
*/
trigger_time = occur_time + dur_time;
/* Add repeating alarms */
if (repeat.repetitions != 0) {
gint i;
time_t repeat_time;
repeat_time = icaldurationtype_as_int (repeat.duration);
for (i = 0; i < repeat.repetitions; i++) {
time_t t;
t = trigger_time + (i + 1) * repeat_time;
if (t >= aod->start && t < aod->end)
add_trigger (aod, auid, t, start, end);
}
}
/* Add the trigger itself */
if (trigger_time >= aod->start && trigger_time < aod->end)
add_trigger (aod, auid, trigger_time, start, end);
}
return TRUE;
}
/* Computes the range of time in which recurrences should be generated for a
* component in order to compute alarm trigger times.
*/
static void
compute_alarm_range (ECalComponent *comp,
GList *alarm_uids,
time_t start,
time_t end,
time_t *alarm_start,
time_t *alarm_end)
{
GList *l;
time_t repeat_time;
*alarm_start = start;
*alarm_end = end;
repeat_time = 0;
for (l = alarm_uids; l; l = l->next) {
const gchar *auid;
ECalComponentAlarm *alarm;
ECalComponentAlarmTrigger trigger;
struct icaldurationtype *dur;
time_t dur_time;
ECalComponentAlarmRepeat repeat;
auid = l->data;
alarm = e_cal_component_get_alarm (comp, auid);
g_return_if_fail (alarm != NULL);
e_cal_component_alarm_get_trigger (alarm, &trigger);
e_cal_component_alarm_get_repeat (alarm, &repeat);
e_cal_component_alarm_free (alarm);
switch (trigger.type) {
case E_CAL_COMPONENT_ALARM_TRIGGER_NONE:
case E_CAL_COMPONENT_ALARM_TRIGGER_ABSOLUTE:
break;
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START:
case E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_END:
dur = &trigger.u.rel_duration;
dur_time = icaldurationtype_as_int (*dur);
if (repeat.repetitions != 0) {
gint rdur;
rdur = repeat.repetitions *
icaldurationtype_as_int (repeat.duration);
repeat_time = MAX (repeat_time, rdur);
}
if (dur->is_neg)
/* If the duration is negative then dur_time
* will be negative as well; that is why we
* subtract to expand the range.
*/
*alarm_end = MAX (*alarm_end, end - dur_time);
else
*alarm_start = MIN (*alarm_start, start - dur_time);
break;
default:
g_return_if_reached ();
}
}
*alarm_start -= repeat_time;
g_warn_if_fail (*alarm_start <= *alarm_end);
}
