icaltime_span icaltime_span_new(struct icaltimetype dtstart, struct icaltimetype dtend, int is_busy)
{
icaltime_span span;
span.is_busy = is_busy;
span.start = icaltime_as_timet_with_zone(dtstart,
dtstart.zone ? dtstart.
zone : icaltimezone_get_utc_timezone());
if (icaltime_is_null_time(dtend)) {
if (!icaltime_is_date(dtstart)) {
/* If dtstart is a DATE-TIME and there is no DTEND nor DURATION
it takes no time */
span.end = span.start;
return span;
} else {
dtend = dtstart;
}
}
span.end = icaltime_as_timet_with_zone(dtend,
dtend.zone ? dtend.
zone : icaltimezone_get_utc_timezone());
if (icaltime_is_date(dtstart)) {
/* no time specified, go until the end of the day.. */
span.end += 60 * 60 * 24 - 1;
}
return span;
}
gint
icaltime_compare_with_current (const icaltimetype *date1,
const icaltimetype *date2,
time_t *current_time_t)
{
gint result = 0;
time_t start1, start2, diff1, diff2;
start1 = icaltime_as_timet_with_zone (*date1, date1->zone != NULL ? date1->zone : e_cal_util_get_system_timezone ());
start2 = icaltime_as_timet_with_zone (*date2, date2->zone != NULL ? date2->zone : e_cal_util_get_system_timezone ());
diff1 = start1 - *current_time_t;
diff2 = start2 - *current_time_t;
if (diff1 != diff2)
{
if (diff1 == 0)
result = -1;
else if (diff2 == 0)
result = 1;
if (diff1 > 0 && diff2 < 0)
result = -1;
else if (diff2 > 0 && diff1 < 0)
result = 1;
else if (diff1 < 0 && diff2 < 0)
result = ABS (diff1) - ABS (diff2);
else if (diff1 > 0 && diff2 > 0)
result = diff1 - diff2;
}
return result;
}
int *icalspanlist_as_freebusy_matrix(icalspanlist *sl, int delta_t)
{
pvl_elem itr;
time_t spanduration_secs;
int *matrix;
time_t matrix_slots;
time_t sl_start, sl_end;
icalerror_check_arg_rz((sl != 0), "spanlist");
if (!delta_t)
delta_t = 3600;
/** calculate the start and end time as time_t **/
sl_start = icaltime_as_timet_with_zone(sl->start, icaltimezone_get_utc_timezone());
sl_end = icaltime_as_timet_with_zone(sl->end, icaltimezone_get_utc_timezone());
/** insure that the time period falls on a time boundary divisable
by delta_t */
sl_start /= delta_t;
sl_start *= delta_t;
sl_end /= delta_t;
sl_end *= delta_t;
/** find the duration of this spanlist **/
spanduration_secs = sl_end - sl_start;
/** malloc our matrix, add one extra slot for a final -1 **/
matrix_slots = spanduration_secs / delta_t + 1;
matrix = (int *)malloc(sizeof(int) * matrix_slots);
if (matrix == NULL) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return NULL;
}
memset(matrix, 0, sizeof(int) * matrix_slots);
matrix[matrix_slots - 1] = -1;
/* loop through each span and mark the slots in the array */
for (itr = pvl_head(sl->spans); itr != 0; itr = pvl_next(itr)) {
struct icaltime_span *s = (struct icaltime_span *)pvl_data(itr);
if (s->is_busy == 1) {
time_t offset_start = s->start / delta_t - sl_start / delta_t;
time_t offset_end = (s->end - 1) / delta_t - sl_start / delta_t + 1;
time_t i;
if (offset_end >= matrix_slots)
offset_end = matrix_slots - 1;
for (i = offset_start; i < offset_end; i++) {
matrix[i]++;
}
}
}
return matrix;
}
icalspanlist *icalspanlist_from_vfreebusy(icalcomponent *comp)
{
icalcomponent *inner;
icalproperty *prop;
icalspanlist *sl;
icalerror_check_arg_rz((comp != NULL), "comp");
inner = icalcomponent_get_inner(comp);
if (!inner)
return NULL;
if ((sl = (icalspanlist *) malloc(sizeof(icalspanlist))) == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
sl->spans = pvl_newlist();
/* cycle through each FREEBUSY property, adding to the spanlist */
for (prop = icalcomponent_get_first_property(inner, ICAL_FREEBUSY_PROPERTY);
prop != NULL;
prop = icalcomponent_get_next_property(inner, ICAL_FREEBUSY_PROPERTY)) {
icaltime_span *s = (icaltime_span *) malloc(sizeof(icaltime_span));
icalparameter *param;
struct icalperiodtype period;
icalparameter_fbtype fbtype;
if (s == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
icalspanlist_free(sl);
return 0;
}
param = icalproperty_get_first_parameter(prop, ICAL_FBTYPE_PARAMETER);
fbtype = (param) ? icalparameter_get_fbtype(param) : ICAL_FBTYPE_BUSY;
switch (fbtype) {
case ICAL_FBTYPE_FREE:
case ICAL_FBTYPE_NONE:
case ICAL_FBTYPE_X:
s->is_busy = 1;
break;
default:
s->is_busy = 0;
}
period = icalproperty_get_freebusy(prop);
s->start = icaltime_as_timet_with_zone(period.start, icaltimezone_get_utc_timezone());
s->end = icaltime_as_timet_with_zone(period.end, icaltimezone_get_utc_timezone());
;
pvl_insert_ordered(sl->spans, compare_span, (void *)s);
}
/** @todo calculate start/end limits.. fill in holes? **/
return sl;
}
static gboolean
execute_search (GcalShellSearchProvider *search_provider)
{
GcalShellSearchProviderPrivate *priv;
guint i;
gchar *search_query;
icaltimezone *zone;
time_t range_start, range_end;
priv = search_provider->priv;
if (!gcal_manager_load_completed (priv->manager))
return TRUE;
zone = gcal_manager_get_system_timezone (priv->manager);
priv->pending_search->date = icaltime_current_time_with_zone (zone);
icaltime_adjust (&(priv->pending_search->date), -7, 0, 0, 0); /* -1 weeks from today */
range_start = icaltime_as_timet_with_zone (priv->pending_search->date, zone);
icaltime_adjust (&(priv->pending_search->date), 21 * 2, 0, 0, 0); /* +3 weeks from today */
range_end = icaltime_as_timet_with_zone (priv->pending_search->date, zone);
gcal_manager_set_shell_search_subscriber (priv->manager, E_CAL_DATA_MODEL_SUBSCRIBER (search_provider),
range_start, range_end);
search_query = g_strdup_printf ("(or (contains? \"summary\" \"%s\") (contains? \"description\" \"%s\"))",
priv->pending_search->terms[0], priv->pending_search->terms[0]);
for (i = 1; i < g_strv_length (priv->pending_search->terms); i++)
{
gchar *complete_query;
gchar *second_query = g_strdup_printf ("(or (contains? \"summary\" \"%s\") (contains? \"description\" \"%s\"))",
priv->pending_search->terms[0], priv->pending_search->terms[0]);
complete_query = g_strdup_printf ("(and %s %s)", search_query, second_query);
g_free (second_query);
g_free (search_query);
search_query = complete_query;
}
gcal_manager_set_shell_search_query (priv->manager, search_query);
g_free (search_query);
priv->scheduled_search_id = 0;
g_application_hold (g_application_get_default ());
return FALSE;
}
static time_t
get_time_from_property (icalcomponent *ical,
icalproperty_kind prop_kind,
struct icaltimetype (* get_prop_func) (const icalproperty *prop),
icaltimezone *default_zone)
{
icalproperty *prop;
struct icaltimetype ical_time;
icalparameter *param;
icaltimezone *timezone = NULL;
prop = icalcomponent_get_first_property (ical, prop_kind);
if (!prop)
return 0;
ical_time = get_prop_func (prop);
param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
if (param)
timezone = icaltimezone_get_builtin_timezone_from_tzid (icalparameter_get_tzid (param));
else if (icaltime_is_utc (ical_time))
timezone = icaltimezone_get_utc_timezone ();
else
timezone = default_zone;
return icaltime_as_timet_with_zone (ical_time, timezone);
}
/**
* time_add_month_with_zone:
* @time: A time_t value.
* @months: Number of months to add.
* @zone: Timezone to use.
*
* Adds or subtracts a number of months to/from the given time_t value, using
* the given timezone.
*
* If the day would be off the end of the month (e.g. adding 1 month to
* 30th January, would lead to an invalid day, 30th February), it moves it
* down to the last day in the month, e.g. 28th Feb (or 29th in a leap year.)
*
* NOTE: this function is only here to make the transition to the timezone
* functions easier. New code should use icaltimetype values and
* icaltime_adjust() to add or subtract days, hours, minutes & seconds.
*
* Return value: a time_t value containing @time plus the months added.
*/
time_t
time_add_month_with_zone (time_t time, int months, icaltimezone *zone)
{
struct icaltimetype tt;
int day, days_in_month;
/* Convert to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Add on the number of months. */
tt.month += months;
/* Save the day, and set it to 1, so we don't overflow into the next
month. */
day = tt.day;
tt.day = 1;
/* Normalize it, fixing any month overflow. */
tt = icaltime_normalize (tt);
/* If we go past the end of a month, set it to the last day. */
days_in_month = time_days_in_month (tt.year, tt.month - 1);
if (day > days_in_month)
day = days_in_month;
tt.day = day;
/* Convert back to a time_t. */
return icaltime_as_timet_with_zone (tt, zone);
}
/**
* time_week_begin_with_zone:
* @time: A time_t value.
* @week_start_day: Day to use as the starting of the week.
* @zone: Timezone to use.
*
* Returns the start of the week containing the given time_t, using the given
* timezone. week_start_day should use the same values as mktime(),
* i.e. 0 (Sun) to 6 (Sat).
* NOTE: this function is only here to make the transition to the timezone
* functions easier. New code should use icaltimetype values and
* icaltime_adjust() to add or subtract days, hours, minutes & seconds.
*
* Return value: the beginning of the week.
*/
time_t
time_week_begin_with_zone (time_t time, int week_start_day, icaltimezone *zone)
{
struct icaltimetype tt;
int weekday, offset;
/* Convert to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Get the weekday. */
weekday = time_day_of_week (tt.day, tt.month - 1, tt.year);
/* Calculate the current offset from the week start day. */
offset = (weekday + 7 - week_start_day) % 7;
/* Set it to the start of the month. */
tt.day -= offset;
tt.hour = 0;
tt.minute = 0;
tt.second = 0;
/* Normalize it, to fix any overflow. */
tt = icaltime_normalize (tt);
/* Convert back to a time_t. */
return icaltime_as_timet_with_zone (tt, zone);
}
/**
* calendar_config_get_hide_completed_tasks_sexp:
*
* @get_completed: Whether to form subexpression that
* gets completed or not completed tasks.
* Returns the subexpression to use to filter out completed tasks according
* to the config settings. The returned sexp should be freed.
**/
char*
calendar_config_get_hide_completed_tasks_sexp (gboolean get_completed)
{
char *sexp = NULL;
if (calendar_config_get_hide_completed_tasks ()) {
CalUnits units;
gint value;
units = calendar_config_get_hide_completed_tasks_units ();
value = calendar_config_get_hide_completed_tasks_value ();
if (value == 0) {
/* If the value is 0, we want to hide completed tasks
immediately, so we filter out all complete/incomplete tasks.*/
if (!get_completed)
sexp = g_strdup ("(not is-completed?)");
else
sexp = g_strdup ("(is-completed?)");
} else {
char *isodate;
icaltimezone *zone;
struct icaltimetype tt;
time_t t;
/* Get the current time, and subtract the appropriate
number of days/hours/minutes. */
zone = calendar_config_get_icaltimezone ();
tt = icaltime_current_time_with_zone (zone);
switch (units) {
case CAL_DAYS:
icaltime_adjust (&tt, -value, 0, 0, 0);
break;
case CAL_HOURS:
icaltime_adjust (&tt, 0, -value, 0, 0);
break;
case CAL_MINUTES:
icaltime_adjust (&tt, 0, 0, -value, 0);
break;
default:
g_return_val_if_reached (NULL);
}
t = icaltime_as_timet_with_zone (tt, zone);
/* Convert the time to an ISO date string, and build
the query sub-expression. */
isodate = isodate_from_time_t (t);
if (!get_completed)
sexp = g_strdup_printf ("(not (completed-before? (make-time \"%s\")))", isodate);
else
sexp = g_strdup_printf ("(completed-before? (make-time \"%s\"))", isodate);
g_free (isodate);
}
}
return sexp;
}
/* (completed-before? TIME)
*
* TIME - time_t
*
* Returns a boolean indicating whether the component was completed on or
* before the given time (i.e. it checks the COMPLETED property).
* This is really only useful for TODO components.
*/
static ESExpResult *
func_completed_before (ESExp *esexp,
gint argc,
ESExpResult **argv,
gpointer data)
{
SearchContext *ctx = data;
ESExpResult *result;
struct icaltimetype *tt;
icaltimezone *zone;
gboolean retval = FALSE;
time_t before_time, completed_time;
/* Check argument types */
if (argc != 1) {
e_sexp_fatal_error (esexp, _("\"%s\" expects one argument"),
"completed-before");
return NULL;
}
if (argv[0]->type != ESEXP_RES_TIME) {
e_sexp_fatal_error (esexp, _("\"%s\" expects the first "
"argument to be a time_t"),
"completed-before");
return NULL;
}
before_time = argv[0]->value.time;
e_cal_component_get_completed (ctx->comp, &tt);
if (tt) {
/* COMPLETED must be in UTC. */
zone = icaltimezone_get_utc_timezone ();
completed_time = icaltime_as_timet_with_zone (*tt, zone);
#if 0
g_print ("Query Time : %s", ctime (&before_time));
g_print ("Completed Time: %s", ctime (&completed_time));
#endif
/* We want to return TRUE if before_time is after
* completed_time. */
if (difftime (before_time, completed_time) > 0) {
#if 0
g_print (" Returning TRUE\n");
#endif
retval = TRUE;
}
e_cal_component_free_icaltimetype (tt);
}
result = e_sexp_result_new (esexp, ESEXP_RES_BOOL);
result->value.boolean = retval;
return result;
}
/**
* time_add_day_with_zone:
* @time: A time_t value.
* @days: Number of days to add.
* @zone: Timezone to use.
*
* Adds or subtracts a number of days to/from the given time_t value, using
* the given timezone.
* NOTE: this function is only here to make the transition to the timezone
* functions easier. New code should use icaltimetype values and
* icaltime_adjust() to add or subtract days, hours, minutes & seconds.
*
* Return value: a time_t value containing @time plus the days added.
*/
time_t
time_add_day_with_zone (time_t time, int days, icaltimezone *zone)
{
struct icaltimetype tt;
/* Convert to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Add/subtract the number of days. */
icaltime_adjust (&tt, days, 0, 0, 0);
/* Convert back to a time_t. */
return icaltime_as_timet_with_zone (tt, zone);
}
/** Get timestamp of last sync.
*
* @param cb 3E calendar backend.
*
* @return Timestamp in local time.
*/
time_t e_cal_backend_3e_get_sync_timestamp(ECalBackend3e *cb)
{
time_t stamp = 0;
g_static_rw_lock_reader_lock(&cb->priv->cache_lock);
const char *ts = e_cal_backend_cache_get_server_utc_time(cb->priv->cache);
g_static_rw_lock_reader_unlock(&cb->priv->cache_lock);
if (ts)
{
icaltimetype time = icaltime_from_string(ts);
stamp = icaltime_as_timet_with_zone(time, NULL);
}
return stamp;
}
/**
* time_from_isodate:
* @str: Date/time value in ISO 8601 format.
*
* Converts an ISO 8601 UTC time string into a time_t value.
*
* Return value: Time_t corresponding to the specified ISO string.
* Note that we only allow UTC times at present.
**/
time_t
time_from_isodate (const char *str)
{
struct icaltimetype tt = icaltime_null_time ();
icaltimezone *utc_zone;
int len, i;
g_return_val_if_fail (str != NULL, -1);
/* yyyymmdd[Thhmmss[Z]] */
len = strlen (str);
if (!(len == 8 || len == 15 || len == 16))
return -1;
for (i = 0; i < len; i++)
if (!((i != 8 && i != 15 && isdigit (str[i]))
|| (i == 8 && str[i] == 'T')
|| (i == 15 && str[i] == 'Z')))
return -1;
#define digit_at(x,y) (x[y] - '0')
tt.year = digit_at (str, 0) * 1000
+ digit_at (str, 1) * 100
+ digit_at (str, 2) * 10
+ digit_at (str, 3);
tt.month = digit_at (str, 4) * 10
+ digit_at (str, 5);
tt.day = digit_at (str, 6) * 10
+ digit_at (str, 7);
if (len > 8) {
tt.hour = digit_at (str, 9) * 10
+ digit_at (str, 10);
tt.minute = digit_at (str, 11) * 10
+ digit_at (str, 12);
tt.second = digit_at (str, 13) * 10
+ digit_at (str, 14);
}
utc_zone = icaltimezone_get_utc_timezone ();
return icaltime_as_timet_with_zone (tt, utc_zone);
}
/**
* time_day_begin_with_zone:
* @time: A time_t value.
* @zone: Timezone to use.
*
* Returns the start of the day containing the given time_t, using the given
* timezone.
* NOTE: this function is only here to make the transition to the timezone
* functions easier. New code should use icaltimetype values and
* icaltime_adjust() to add or subtract days, hours, minutes & seconds.
*
* Return value: the beginning of the day.
*/
time_t
time_day_begin_with_zone (time_t time, icaltimezone *zone)
{
struct icaltimetype tt;
/* Convert to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Set it to the start of the day. */
tt.hour = 0;
tt.minute = 0;
tt.second = 0;
/* Convert back to a time_t. */
return icaltime_as_timet_with_zone (tt, zone);
}
static gboolean
cal_searching_got_instance_cb (ECalComponent *comp,
time_t instance_start,
time_t instance_end,
gpointer user_data)
{
struct GenerateInstancesData *gid = user_data;
ECalShellViewPrivate *priv;
ECalComponentDateTime dt;
time_t *value;
g_return_val_if_fail (gid != NULL, FALSE);
if (g_cancellable_is_cancelled (gid->cancellable))
return FALSE;
g_return_val_if_fail (gid->cal_shell_view != NULL, FALSE);
g_return_val_if_fail (gid->cal_shell_view->priv != NULL, FALSE);
e_cal_component_get_dtstart (comp, &dt);
if (dt.tzid && dt.value) {
icaltimezone *zone = NULL;
e_cal_client_get_timezone_sync (
gid->client, dt.tzid, &zone, gid->cancellable, NULL);
if (g_cancellable_is_cancelled (gid->cancellable))
return FALSE;
if (zone)
instance_start = icaltime_as_timet_with_zone (*dt.value, zone);
}
e_cal_component_free_datetime (&dt);
priv = gid->cal_shell_view->priv;
value = g_new (time_t, 1);
*value = instance_start;
if (!g_slist_find_custom (priv->search_hit_cache, value, cal_time_t_ptr_compare))
priv->search_hit_cache = g_slist_append (priv->search_hit_cache, value);
else
g_free (value);
return TRUE;
}
/**
* time_day_end_with_zone:
* @time: A time_t value.
* @zone: Timezone to use.
*
* Returns the end of the day containing the given time_t, using the given
* timezone. (The end of the day is the start of the next day.)
* NOTE: this function is only here to make the transition to the timezone
* functions easier. New code should use icaltimetype values and
* icaltime_adjust() to add or subtract days, hours, minutes & seconds.
*
* Return value: the end of the day.
*/
time_t
time_day_end_with_zone (time_t time, icaltimezone *zone)
{
struct icaltimetype tt;
/* Convert to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Set it to the start of the next day. */
tt.day++;
tt.hour = 0;
tt.minute = 0;
tt.second = 0;
/* Normalize it, to fix any overflow. */
tt = icaltime_normalize (tt);
/* Convert back to a time_t. */
return icaltime_as_timet_with_zone (tt, zone);
}
/* Event handler for day groups in the month item. A button press makes the calendar jump to the
* selected day and destroys the Go-to dialog box.
*/
static void
ecal_event (ECalendarItem *calitem, gpointer user_data)
{
GoToDialog *dlg = user_data;
GDate start_date, end_date;
struct icaltimetype tt = icaltime_null_time ();
time_t et;
e_calendar_item_get_selection (calitem, &start_date, &end_date);
tt.year = g_date_get_year (&start_date);
tt.month = g_date_get_month (&start_date);
tt.day = g_date_get_day (&start_date);
et = icaltime_as_timet_with_zone (tt, gnome_calendar_get_timezone (dlg->gcal));
gnome_calendar_goto (dlg->gcal, et);
gtk_dialog_response (GTK_DIALOG (dlg->dialog), GTK_RESPONSE_NONE);
/* gnome_dialog_close (GNOME_DIALOG (dlg->dialog)); */
}
static time_t
componenttime_to_utc_timet (const ECalComponentDateTime *dt_time,
ECalRecurResolveTimezoneFn tz_cb,
gpointer tz_cb_data,
const icaltimezone *default_zone)
{
time_t timet = -1;
icaltimezone *zone = NULL;
g_return_val_if_fail (dt_time != NULL, -1);
if (dt_time->value) {
if (dt_time->tzid)
zone = tz_cb (dt_time->tzid, tz_cb_data);
// zone = icaltimezone_get_utc_timezone ();
timet = icaltime_as_timet_with_zone (
*dt_time->value, zone ? zone : default_zone);
}
return timet;
}
static void
gcal_year_view_component_added (ECalDataModelSubscriber *subscriber,
ECalClient *client,
ECalComponent *comp)
{
GcalYearViewPrivate *priv;
GcalYearView *year_view = GCAL_YEAR_VIEW (subscriber);
GcalEventData *data;
GList **days_widgets_array;
GList *l;
gint i, days_span;
ECalComponentDateTime date;
time_t event_start, event_end, range_start, range_end;
icaltimezone *zone;
priv = year_view->priv;
update_selected_dates_from_button_data (year_view);
days_span = icaltime_day_of_year(*(priv->end_selected_date)) - icaltime_day_of_year(*(priv->start_selected_date)) + 1;
days_widgets_array = g_new0 (GList*, days_span);
data = g_new0 (GcalEventData, 1);
data->source = e_client_get_source (E_CLIENT (client));
data->event_component = e_cal_component_clone (comp);
/* check if event belongs to range */
zone = gcal_manager_get_system_timezone (priv->manager);
range_start = icaltime_as_timet_with_zone (*(priv->start_selected_date), zone);
range_end = icaltime_as_timet_with_zone (*(priv->end_selected_date), zone);
e_cal_component_get_dtstart (comp, &date);
event_start = icaltime_as_timet_with_zone (*(date.value), date.value->zone != NULL ? date.value->zone : zone);
e_cal_component_free_datetime (&date);
e_cal_component_get_dtend (comp, &date);
if (date.value != NULL)
event_end = icaltime_as_timet_with_zone (*(date.value), date.value->zone != NULL ? date.value->zone : zone);
else
event_end = event_start;
e_cal_component_free_datetime (&date);
if (!((event_start <= range_start && event_end >= range_end) ||
(event_start >= range_start && event_end <= range_end) ||
(event_start >= range_start && event_start <= range_end) ||
(event_end >= range_start && event_end <= range_end)))
{
g_object_unref (data->event_component);
goto out;
}
add_event_to_day_array (year_view, data, days_widgets_array, days_span);
gtk_stack_set_visible_child_name (GTK_STACK (priv->navigator_stack), "events-list");
for (i = 0; i < days_span; i++)
{
GList *current_day = days_widgets_array[i];
for (l = current_day; l != NULL; l = g_list_next (l))
{
GtkWidget *child_widget = l->data;
gtk_widget_show (child_widget);
g_signal_connect (child_widget, "activate", G_CALLBACK (event_activated), year_view);
g_object_set_data (G_OBJECT (child_widget), "shift", GINT_TO_POINTER (i));
gtk_container_add (GTK_CONTAINER (priv->events_sidebar), child_widget);
}
g_list_free (current_day);
}
out:
g_free (data);
g_free (days_widgets_array);
}
/* 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);
}
/**
* e_cal_util_get_component_occur_times:
* @comp: an #ECalComponent
* @start: (out): Location to store the start time
* @end: (out): Location to store the end time
* @tz_cb: (closure tz_cb_data) (scope call): The #ECalRecurResolveTimezoneFn to call
* @tz_cb_data: (closure): User data to be passed to the @tz_cb callback
* @default_timezone: The default timezone
* @kind: the type of component, indicated with an icalcomponent_kind
*
* Find out when the component starts and stops, being careful about
* recurrences.
*
* Since: 2.32
**/
void
e_cal_util_get_component_occur_times (ECalComponent *comp,
time_t *start,
time_t *end,
ECalRecurResolveTimezoneFn tz_cb,
gpointer tz_cb_data,
const icaltimezone *default_timezone,
icalcomponent_kind kind)
{
struct icalrecurrencetype ir;
ECalComponentDateTime dt_start, dt_end;
g_return_if_fail (comp != NULL);
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
e_cal_recur_ensure_end_dates (comp, FALSE, tz_cb, tz_cb_data);
/* Get dtstart of the component and convert it to UTC */
e_cal_component_get_dtstart (comp, &dt_start);
if ((*start = componenttime_to_utc_timet (&dt_start, tz_cb, tz_cb_data, default_timezone)) == -1)
*start = _TIME_MIN;
e_cal_component_free_datetime (&dt_start);
/* find out end date of component */
*end = _TIME_MAX;
if (kind == ICAL_VTODO_COMPONENT) {
/* max from COMPLETED and DUE properties */
struct icaltimetype *tt = NULL;
time_t completed_time = -1, due_time = -1, max_time;
ECalComponentDateTime dt_due;
e_cal_component_get_completed (comp, &tt);
if (tt) {
/* COMPLETED must be in UTC. */
completed_time = icaltime_as_timet_with_zone (
*tt, icaltimezone_get_utc_timezone ());
e_cal_component_free_icaltimetype (tt);
}
e_cal_component_get_due (comp, &dt_due);
if (dt_due.value != NULL)
due_time = componenttime_to_utc_timet (
&dt_due, tz_cb, tz_cb_data,
default_timezone);
e_cal_component_free_datetime (&dt_due);
max_time = MAX (completed_time, due_time);
if (max_time != -1)
*end = max_time;
} else {
/* ALARMS, EVENTS: DTEND and reccurences */
if (e_cal_component_has_recurrences (comp)) {
GSList *rrules = NULL;
GSList *exrules = NULL;
GSList *elem;
GSList *rdates = NULL;
/* Do the RRULEs, EXRULEs and RDATEs*/
e_cal_component_get_rrule_property_list (comp, &rrules);
e_cal_component_get_exrule_property_list (comp, &exrules);
e_cal_component_get_rdate_list (comp, &rdates);
for (elem = rrules; elem; elem = elem->next) {
time_t rule_end;
icaltimezone *utc_zone;
icalproperty *prop = elem->data;
ir = icalproperty_get_rrule (prop);
utc_zone = icaltimezone_get_utc_timezone ();
rule_end = e_cal_recur_obtain_enddate (
&ir, prop, utc_zone, TRUE);
if (rule_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rule_end > *end) /* new maximum */
*end = rule_end;
}
/* Do the EXRULEs. */
for (elem = exrules; elem; elem = elem->next) {
icalproperty *prop = elem->data;
time_t rule_end;
icaltimezone *utc_zone;
ir = icalproperty_get_exrule (prop);
utc_zone = icaltimezone_get_utc_timezone ();
rule_end = e_cal_recur_obtain_enddate (
&ir, prop, utc_zone, TRUE);
if (rule_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rule_end > *end)
*end = rule_end;
}
/* Do the RDATEs */
for (elem = rdates; elem; elem = elem->next) {
ECalComponentPeriod *p = elem->data;
time_t rdate_end = _TIME_MAX;
/* FIXME: We currently assume RDATEs are in the same timezone
* as DTSTART. We should get the RDATE timezone and convert
* to the DTSTART timezone first. */
/* Check if the end date or duration is set, libical seems to set
* second to -1 to denote an unset time */
if (p->type != E_CAL_COMPONENT_PERIOD_DATETIME || p->u.end.second != -1)
rdate_end = icaltime_as_timet (icaltime_add (p->start, p->u.duration));
else
rdate_end = icaltime_as_timet (p->u.end);
if (rdate_end == -1) /* repeats forever */
*end = _TIME_MAX;
else if (rdate_end > *end)
*end = rdate_end;
}
e_cal_component_free_period_list (rdates);
}
/* Get dtend of the component and convert it to UTC */
e_cal_component_get_dtend (comp, &dt_end);
if (dt_end.value) {
time_t dtend_time;
dtend_time = componenttime_to_utc_timet (
&dt_end, tz_cb, tz_cb_data, default_timezone);
if (dtend_time == -1 || (dtend_time > *end))
*end = dtend_time;
}
e_cal_component_free_datetime (&dt_end);
}
}
int main()
{
icalarray *builtin_timezones;
icaltimetype tt;
int dd, hh, zz, tried = 0;
long zz2 = -1;
set_zone_directory("../../zoneinfo");
icaltimezone_set_tzid_prefix("/softwarestudio.org/");
tt = icaltime_current_time_with_zone(icaltimezone_get_builtin_timezone("America/New_York"));
tt.year = 2038;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
tt.year = 2050;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
tt.year = 1958;
(void)icaltime_as_timet_with_zone(tt, icaltimezone_get_builtin_timezone("PST"));
tried++;
builtin_timezones = icaltimezone_get_builtin_timezones();
printf("got %lu zones\n", (unsigned long)builtin_timezones->num_elements);
if (builtin_timezones->num_elements == 0) {
printf("YIKES. Try running from the build/bin directory\n");
return(1);
}
for (zz = -1; zz < (int)builtin_timezones->num_elements; zz++) {
icaltimezone *zone;
if (zz < 0) {
zone = icaltimezone_get_utc_timezone();
} else {
zone = icalarray_element_at(builtin_timezones, (size_t)zz);
}
tt = icaltime_current_time_with_zone(zone);
for (dd = 0; dd < 370; dd += 17) {
for (hh = 0; hh < 60 * 60 * 24; hh += 567) {
int zz2cnt;
icaltime_adjust(&tt, 0, 0, 0, 1);
for (zz2cnt = 0; zz2cnt < 15; zz2cnt++) {
icaltimezone *zone2;
if (zz2 < 0) {
zone2 = icaltimezone_get_utc_timezone();
} else {
zone2 = icalarray_element_at(builtin_timezones, (size_t)zz2);
}
(void)icaltime_as_timet_with_zone(tt, zone2);
tried++;
zz2++;
if (zz2 >= (long)builtin_timezones->num_elements)
zz2 = -1;
}
}
}
printf("\r%lu %% done",
(zz >= 0 ? zz : 0) * 100 / (unsigned long)builtin_timezones->num_elements);
fflush(stdout);
}
printf("\ntried %d times\n", tried);
return 0;
}
/**
* e2k_timestamp_from_icaltime:
* @itt: an #icaltimetype
*
* Converts @itt to an Exchange timestamp string
*
* Return value: the timestamp, which the caller must free.
**/
gchar *
e2k_timestamp_from_icaltime (struct icaltimetype itt)
{
return e2k_make_timestamp (icaltime_as_timet_with_zone (itt, itt.zone));
}
static ESExpResult *
func_due_in_time_range (ESExp *esexp,
gint argc,
ESExpResult **argv,
gpointer data)
{
SearchContext *ctx = data;
time_t start, end;
ESExpResult *result;
icaltimezone *zone;
ECalComponentDateTime dt;
time_t due_t;
gboolean retval;
/* Check argument types */
if (argc != 2) {
e_sexp_fatal_error (
esexp, _("\"%s\" expects two arguments"),
"due-in-time-range");
return NULL;
}
if (argv[0]->type != ESEXP_RES_TIME) {
e_sexp_fatal_error (
esexp, _("\"%s\" expects the first "
"argument to be a time_t"),
"due-in-time-range");
return NULL;
}
start = argv[0]->value.time;
if (argv[1]->type != ESEXP_RES_TIME) {
e_sexp_fatal_error (
esexp, _("\"%s\" expects the second "
"argument to be a time_t"),
"due-in-time-range");
return NULL;
}
end = argv[1]->value.time;
e_cal_component_get_due (ctx->comp, &dt);
if (dt.value != NULL) {
zone = resolve_tzid (dt.tzid, ctx);
if (zone)
due_t = icaltime_as_timet_with_zone (*dt.value,zone);
else
due_t = icaltime_as_timet (*dt.value);
}
if (dt.value != NULL && (due_t <= end && due_t >= start))
retval = TRUE;
else
retval = FALSE;
result = e_sexp_result_new (esexp, ESEXP_RES_BOOL);
result->value.boolean = retval;
e_cal_component_free_datetime (&dt);
return result;
}
static void
annum_shell_view_date_navigator_selection_changed_cb (AnnumShellView * self,
ECalendarItem * calitem)
{
AnnumShellContent *prox_shell_content;
GnomeCalendarViewType switch_to;
GnomeCalendarViewType view_type;
GnomeCalendar *calendar;
ECalModel *model;
GDate start_date, end_date;
GDate new_start_date, new_end_date;
icaltimetype tt;
icaltimezone *timezone;
time_t start, end, new_time;
gboolean starts_on_week_start_day;
gint new_days_shown;
gint week_start_day;
prox_shell_content = self->priv->prox_shell_content;
calendar = annum_shell_content_get_calendar (prox_shell_content);
model = gnome_calendar_get_model (calendar);
view_type = gnome_calendar_get_view (calendar);
switch_to = view_type;
timezone = e_cal_model_get_timezone (model);
week_start_day = e_cal_model_get_week_start_day (model);
e_cal_model_get_time_range (model, &start, &end);
time_to_gdate_with_zone (&start_date, start, timezone);
time_to_gdate_with_zone (&end_date, end, timezone);
if (view_type == GNOME_CAL_MONTH_VIEW) {
EWeekView *week_view;
ECalendarView *calendar_view;
gboolean multi_week_view;
gboolean compress_weekend;
calendar_view =
gnome_calendar_get_calendar_view (calendar,
GNOME_CAL_MONTH_VIEW);
week_view = E_WEEK_VIEW (calendar_view);
multi_week_view = e_week_view_get_multi_week_view (week_view);
compress_weekend = e_week_view_get_compress_weekend (week_view);
if (week_start_day == 0
&& (!multi_week_view || compress_weekend))
g_date_add_days (&start_date, 1);
}
g_date_subtract_days (&end_date, 1);
e_calendar_item_get_selection (calitem, &new_start_date, &new_end_date);
/* There used to be a check here to make sure the rest of the
* code only ran when the date actually changed. We do not
* this to simplify always having three columns for the day
* view.
*/
new_days_shown =
g_date_get_julian (&new_end_date) -
g_date_get_julian (&new_start_date) + 1;
/* If a complete week is selected we show the week view.
* Note that if weekends are compressed and the week start
* day is set to Sunday, we don't actually show complete
* weeks in the week view, so this may need tweaking. */
starts_on_week_start_day =
(g_date_get_weekday (&new_start_date) % 7 == week_start_day);
/* Update selection to be in the new time range. */
tt = icaltime_null_time ();
tt.year = g_date_get_year (&new_start_date);
tt.month = g_date_get_month (&new_start_date);
tt.day = g_date_get_day (&new_start_date);
new_time = icaltime_as_timet_with_zone (tt, timezone);
/* Switch views as appropriate, and change the number of
* days or weeks shown. */
if (new_days_shown > 9) {
if (view_type != GNOME_CAL_LIST_VIEW) {
ECalendarView *calendar_view;
calendar_view =
gnome_calendar_get_calendar_view (calendar,
GNOME_CAL_MONTH_VIEW);
e_week_view_set_weeks_shown (E_WEEK_VIEW
(calendar_view),
(new_days_shown + 6) / 7);
switch_to = GNOME_CAL_MONTH_VIEW;
}
} else if (new_days_shown == 7 && starts_on_week_start_day)
switch_to = GNOME_CAL_WEEK_VIEW;
else {
ECalendarView *calendar_view;
calendar_view =
gnome_calendar_get_calendar_view (calendar,
GNOME_CAL_DAY_VIEW);
/* We always show three days */
if (new_days_shown == 1)
new_days_shown = 3;
e_day_view_set_days_shown (E_DAY_VIEW (calendar_view),
new_days_shown);
if (new_days_shown != 5 || !starts_on_week_start_day)
switch_to = GNOME_CAL_DAY_VIEW;
else if (view_type != GNOME_CAL_WORK_WEEK_VIEW)
switch_to = GNOME_CAL_DAY_VIEW;
}
/* Make the views display things properly. */
gnome_calendar_update_view_times (calendar, new_time);
gnome_calendar_set_view (calendar, switch_to);
gnome_calendar_set_range_selected (calendar, TRUE);
gnome_calendar_notify_dates_shown_changed (calendar);
g_signal_emit (self, signals[DATE_CHANGED], 0, switch_to);
}