From a0cae4356aad06ac2e5737baaef6fb1c70582ff6 Mon Sep 17 00:00:00 2001 From: Milan Crha Date: Fri, 17 May 2019 21:58:55 +0200 Subject: [PATCH] Port to libecal-2.0 Fixes https://gitlab.gnome.org/GNOME/gnome-calendar/merge_requests/70 --- .../evolution/e-cal-data-model-subscriber.c | 2 +- contrib/evolution/e-cal-data-model.c | 502 ++++++++++++------ contrib/evolution/e-cal-data-model.h | 9 +- meson.build | 2 +- src/core/gcal-event.c | 300 ++++++----- src/core/gcal-manager.c | 27 +- src/core/gcal-manager.h | 6 +- src/core/gcal-recurrence.c | 119 +++-- src/core/gcal-recurrence.h | 2 +- src/gui/gcal-edit-dialog.c | 16 +- src/gui/gcal-event-widget.c | 16 +- src/gui/gcal-event-widget.h | 2 - src/gui/gcal-window.c | 1 - src/utils/gcal-date-time-utils.c | 51 +- src/utils/gcal-date-time-utils.h | 6 +- src/utils/gcal-utils.c | 130 ++--- src/utils/gcal-utils.h | 12 +- src/views/gcal-month-popover.c | 7 +- src/views/gcal-year-view.c | 8 +- 19 files changed, 732 insertions(+), 486 deletions(-) diff --git a/contrib/evolution/e-cal-data-model-subscriber.c b/contrib/evolution/e-cal-data-model-subscriber.c index 04af1ae1..328b58ac 100644 --- a/contrib/evolution/e-cal-data-model-subscriber.c +++ b/contrib/evolution/e-cal-data-model-subscriber.c @@ -29,7 +29,7 @@ e_cal_data_model_subscriber_default_init (ECalDataModelSubscriberInterface *ifac * e_cal_data_model_subscriber_component_added: * @subscriber: an #ECalDataModelSubscriber * @client: an #ECalClient, which notifies about the component addition - * @icalcomp: an #ECalComponent which was added + * @comp: an #ECalComponent which was added * * Notifies the @subscriber about an added component which belongs * to the time range used by the @subscriber. diff --git a/contrib/evolution/e-cal-data-model.c b/contrib/evolution/e-cal-data-model.c index 7ab6169d..4e13d7fe 100644 --- a/contrib/evolution/e-cal-data-model.c +++ b/contrib/evolution/e-cal-data-model.c @@ -17,92 +17,106 @@ */ #include -/*#include */ +/* #include */ #include "e-cal-data-model.h" -#define LOCK_PROPS() g_rec_mutex_lock (&data_model->priv->props_lock) -#define UNLOCK_PROPS() g_rec_mutex_unlock (&data_model->priv->props_lock) - -static void +void cal_comp_get_instance_times (ECalClient *client, - icalcomponent *icalcomp, - const icaltimezone *default_zone, - time_t *instance_start, - gboolean *start_is_date, - time_t *instance_end, - gboolean *end_is_date, + ICalComponent *icomp, + const ICalTimezone *default_zone, + ICalTime **out_instance_start, + ICalTime **out_instance_end, GCancellable *cancellable) { - struct icaltimetype start_time, end_time; - const icaltimezone *zone = default_zone; + ICalTime *start_time, *end_time; + const ICalTimezone *zone = default_zone; g_return_if_fail (E_IS_CAL_CLIENT (client)); - g_return_if_fail (icalcomp != NULL); - g_return_if_fail (instance_start != NULL); - g_return_if_fail (instance_end != NULL); + g_return_if_fail (icomp != NULL); + g_return_if_fail (out_instance_start != NULL); + g_return_if_fail (out_instance_end != NULL); - start_time = icalcomponent_get_dtstart (icalcomp); - end_time = icalcomponent_get_dtend (icalcomp); - if (icaltime_is_null_time (end_time)) - end_time = start_time; + start_time = i_cal_component_get_dtstart (icomp); + end_time = i_cal_component_get_dtend (icomp); - if (start_time.zone) { - zone = start_time.zone; + /* Some event can have missing DTEND, then use the start_time for them */ + if (!end_time || i_cal_time_is_null_time (end_time)) { + g_clear_object (&end_time); + + end_time = i_cal_time_clone (start_time); + } + + if (i_cal_time_get_timezone (start_time)) { + zone = i_cal_time_get_timezone (start_time); } else { - icalparameter *param = NULL; - icalproperty *prop = icalcomponent_get_first_property (icalcomp, ICAL_DTSTART_PROPERTY); + ICalParameter *param = NULL; + ICalProperty *prop = i_cal_component_get_first_property (icomp, I_CAL_DTSTART_PROPERTY); if (prop) { - param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER); + param = i_cal_property_get_first_parameter (prop, I_CAL_TZID_PARAMETER); if (param) { const gchar *tzid = NULL; - icaltimezone *st_zone = NULL; + ICalTimezone *st_zone = NULL; - tzid = icalparameter_get_tzid (param); - if (tzid) - e_cal_client_get_timezone_sync (client, tzid, &st_zone, cancellable, NULL); + tzid = i_cal_parameter_get_tzid (param); + if (tzid && !e_cal_client_get_timezone_sync (client, tzid, &st_zone, cancellable, NULL)) + st_zone = NULL; if (st_zone) zone = st_zone; + + g_object_unref (param); } - } + + g_object_unref (prop); + } } - *instance_start = icaltime_as_timet_with_zone (start_time, zone); - if (start_is_date) - *start_is_date = start_time.is_date; + *out_instance_start = i_cal_time_clone (start_time); + i_cal_time_set_timezone (*out_instance_start, zone); - if (end_time.zone) { - zone = end_time.zone; + if (i_cal_time_get_timezone (end_time)) { + zone = i_cal_time_get_timezone (end_time); } else { - icalparameter *param = NULL; - icalproperty *prop = icalcomponent_get_first_property (icalcomp, ICAL_DTSTART_PROPERTY); + ICalParameter *param = NULL; + ICalProperty *prop = i_cal_component_get_first_property (icomp, I_CAL_DTEND_PROPERTY); + + if (!prop) + prop = i_cal_component_get_first_property (icomp, I_CAL_DTSTART_PROPERTY); if (prop) { - param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER); + param = i_cal_property_get_first_parameter (prop, I_CAL_TZID_PARAMETER); if (param) { const gchar *tzid = NULL; - icaltimezone *end_zone = NULL; + ICalTimezone *end_zone = NULL; - tzid = icalparameter_get_tzid (param); - if (tzid) - e_cal_client_get_timezone_sync (client, tzid, &end_zone, cancellable, NULL); + tzid = i_cal_parameter_get_tzid (param); + if (tzid && !e_cal_client_get_timezone_sync (client, tzid, &end_zone, cancellable, NULL)) + end_zone = NULL; if (end_zone) zone = end_zone; - } - } + g_object_unref (param); + } + + g_object_unref (prop); + } } - *instance_end = icaltime_as_timet_with_zone (end_time, zone); - if (end_is_date) - *end_is_date = end_time.is_date; + *out_instance_end = i_cal_time_clone (end_time); + i_cal_time_set_timezone (*out_instance_end, zone); + + g_clear_object (&start_time); + g_clear_object (&end_time); } +#define LOCK_PROPS() g_rec_mutex_lock (&data_model->priv->props_lock) +#define UNLOCK_PROPS() g_rec_mutex_unlock (&data_model->priv->props_lock) + struct _ECalDataModelPrivate { GThread *main_thread; ECalDataModelSubmitThreadJobFunc submit_thread_job_func; @@ -113,9 +127,10 @@ struct _ECalDataModelPrivate { gboolean disposing; gboolean expand_recurrences; + gboolean skip_cancelled; gchar *filter; gchar *full_filter; /* to be used with views */ - icaltimezone *zone; + ICalTimezone *zone; time_t range_start; time_t range_end; @@ -130,7 +145,8 @@ struct _ECalDataModelPrivate { enum { PROP_0, PROP_EXPAND_RECURRENCES, - PROP_TIMEZONE + PROP_TIMEZONE, + PROP_SKIP_CANCELLED }; enum { @@ -165,7 +181,7 @@ typedef struct _ViewData { GHashTable *components; /* ECalComponentId ~> ComponentData */ GHashTable *lost_components; /* ECalComponentId ~> ComponentData; when re-running view, valid till 'complete' is received */ gboolean received_complete; - GSList *to_expand_recurrences; /* icalcomponent */ + GSList *to_expand_recurrences; /* ICalComponent */ GSList *expanded_recurrences; /* ComponentData */ gint pending_expand_recurrences; /* how many is waiting to be processed */ @@ -212,8 +228,8 @@ static gboolean component_data_equal (ComponentData *comp_data1, ComponentData *comp_data2) { - icalcomponent *icomp1, *icomp2; - struct icaltimetype tt1, tt2; + ICalComponent *icomp1, *icomp2; + ICalTime *tt1, *tt2; gchar *as_str1, *as_str2; gboolean equal; @@ -231,28 +247,40 @@ component_data_equal (ComponentData *comp_data1, icomp2 = e_cal_component_get_icalcomponent (comp_data2->component); if (!icomp1 || !icomp2 || - icalcomponent_get_sequence (icomp1) != icalcomponent_get_sequence (icomp2) || - g_strcmp0 (icalcomponent_get_uid (icomp1), icalcomponent_get_uid (icomp2)) != 0) + i_cal_component_get_sequence (icomp1) != i_cal_component_get_sequence (icomp2) || + g_strcmp0 (i_cal_component_get_uid (icomp1), i_cal_component_get_uid (icomp2)) != 0) return FALSE; - tt1 = icalcomponent_get_recurrenceid (icomp1); - tt2 = icalcomponent_get_recurrenceid (icomp2); - if ((icaltime_is_valid_time (tt1) ? 1 : 0) != (icaltime_is_valid_time (tt2) ? 1 : 0) || - (icaltime_is_null_time (tt1) ? 1 : 0) != (icaltime_is_null_time (tt2) ? 1 : 0) || - icaltime_compare (tt1, tt2) != 0) + tt1 = i_cal_component_get_recurrenceid (icomp1); + tt2 = i_cal_component_get_recurrenceid (icomp2); + if (((!tt1 || i_cal_time_is_valid_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_valid_time (tt2)) ? 1 : 0) || + ((!tt1 || i_cal_time_is_null_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_null_time (tt2)) ? 1 : 0) || + i_cal_time_compare (tt1, tt2) != 0) { + g_clear_object (&tt1); + g_clear_object (&tt2); return FALSE; + } - tt1 = icalcomponent_get_dtstamp (icomp1); - tt2 = icalcomponent_get_dtstamp (icomp2); - if ((icaltime_is_valid_time (tt1) ? 1 : 0) != (icaltime_is_valid_time (tt2) ? 1 : 0) || - (icaltime_is_null_time (tt1) ? 1 : 0) != (icaltime_is_null_time (tt2) ? 1 : 0) || - icaltime_compare (tt1, tt2) != 0) + g_clear_object (&tt1); + g_clear_object (&tt2); + + tt1 = i_cal_component_get_dtstamp (icomp1); + tt2 = i_cal_component_get_dtstamp (icomp2); + if (((!tt1 || i_cal_time_is_valid_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_valid_time (tt2)) ? 1 : 0) || + ((!tt1 || i_cal_time_is_null_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_null_time (tt2)) ? 1 : 0) || + i_cal_time_compare (tt1, tt2) != 0) { + g_clear_object (&tt1); + g_clear_object (&tt2); return FALSE; + } + + g_clear_object (&tt1); + g_clear_object (&tt2); /* Maybe not so effective compare, but might be still more effective than updating whole UI with false notifications */ - as_str1 = icalcomponent_as_ical_string_r (icomp1); - as_str2 = icalcomponent_as_ical_string_r (icomp2); + as_str1 = i_cal_component_as_ical_string (icomp1); + as_str2 = i_cal_component_as_ical_string (icomp2); equal = g_strcmp0 (as_str1, as_str2) == 0; @@ -275,8 +303,8 @@ view_data_new (ECalClient *client) view_data->is_used = TRUE; view_data->client = g_object_ref (client); view_data->components = g_hash_table_new_full ( - (GHashFunc) e_cal_component_id_hash, (GEqualFunc) e_cal_component_id_equal, - (GDestroyNotify) e_cal_component_free_id, component_data_free); + e_cal_component_id_hash, e_cal_component_id_equal, + e_cal_component_id_free, component_data_free); return view_data; } @@ -328,7 +356,7 @@ view_data_unref (gpointer ptr) g_hash_table_destroy (view_data->components); if (view_data->lost_components) g_hash_table_destroy (view_data->lost_components); - g_slist_free_full (view_data->to_expand_recurrences, (GDestroyNotify) icalcomponent_free); + g_slist_free_full (view_data->to_expand_recurrences, g_object_unref); g_slist_free_full (view_data->expanded_recurrences, component_data_free); g_rec_mutex_clear (&view_data->lock); g_free (view_data); @@ -519,13 +547,6 @@ cal_data_model_call_submit_thread_job (gpointer user_data) /** * e_cal_data_model_submit_thread_job: * @data_model: an #ECalDataModel - * @description: user-friendly description of the job, to be shown in UI - * @alert_ident: in case of an error, this alert identificator is used - * for EAlert construction - * @alert_arg_0: (allow-none): in case of an error, use this string as - * the first argument to the EAlert construction; the second argument - * is the actual error message; can be #NULL, in which case only - * the error message is passed to the EAlert construction * @func: function to be run in a dedicated thread * @user_data: (allow-none): custom data passed into @func; can be #NULL * @free_user_data: (allow-none): function to be called on @user_data, @@ -615,7 +636,7 @@ cal_data_model_foreach_subscriber_in_range (ECalDataModel *data_model, if ((in_range_start == (time_t) 0 && in_range_end == (time_t) 0) || (subs_data->range_start == (time_t) 0 && subs_data->range_end == (time_t) 0) || - (subs_data->range_start < in_range_end && subs_data->range_end > in_range_start)) + (subs_data->range_start <= in_range_end && subs_data->range_end >= in_range_start)) func (data_model, client, subs_data->subscriber, user_data); } @@ -712,7 +733,9 @@ cal_data_model_remove_one_view_component_cb (ECalDataModel *data_model, g_return_if_fail (id != NULL); - e_cal_data_model_subscriber_component_removed (subscriber, client, id->uid, id->rid); + e_cal_data_model_subscriber_component_removed (subscriber, client, + e_cal_component_id_get_uid (id), + e_cal_component_id_get_rid (id)); } static void @@ -818,8 +841,8 @@ cal_data_model_update_full_filter (ECalDataModel *data_model) iso_start = isodate_from_time_t (range_start); iso_end = isodate_from_time_t (range_end); - if (data_model->priv->zone && data_model->priv->zone != icaltimezone_get_utc_timezone ()) - default_tzloc = icaltimezone_get_location (data_model->priv->zone); + if (data_model->priv->zone && data_model->priv->zone != i_cal_timezone_get_utc_timezone ()) + default_tzloc = i_cal_timezone_get_location (data_model->priv->zone); if (!default_tzloc) default_tzloc = ""; @@ -945,7 +968,9 @@ cal_data_model_process_added_component (ECalDataModel *data_model, if (g_hash_table_remove (new_subscribers, subscriber)) e_cal_data_model_subscriber_component_modified (subscriber, view_data->client, comp_data->component); else if (old_id) - e_cal_data_model_subscriber_component_removed (subscriber, view_data->client, old_id->uid, old_id->rid); + e_cal_data_model_subscriber_component_removed (subscriber, view_data->client, + e_cal_component_id_get_uid (old_id), + e_cal_component_id_get_rid (old_id)); } /* Those which left in the new_subscribers have the component added. */ @@ -967,8 +992,7 @@ cal_data_model_process_added_component (ECalDataModel *data_model, view_data_unlock (view_data); - if (old_id) - e_cal_component_free_id (old_id); + e_cal_component_id_free (old_id); } typedef struct _GatherComponentsData { @@ -994,7 +1018,7 @@ cal_data_model_gather_components (gpointer key, g_return_if_fail (gather_data->pcomponent_ids != NULL || gather_data->component_ids_hash != NULL); g_return_if_fail (gather_data->pcomponent_ids == NULL || gather_data->component_ids_hash == NULL); - if ((gather_data->all_instances || !comp_data->is_detached) && g_strcmp0 (id->uid, gather_data->uid) == 0) { + if ((gather_data->all_instances || !comp_data->is_detached) && g_strcmp0 (e_cal_component_id_get_uid (id), gather_data->uid) == 0) { if (gather_data->component_ids_hash) { ComponentData *comp_data_copy; @@ -1055,21 +1079,21 @@ cal_data_model_notify_recurrences_cb (gpointer user_data) gathered_uids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); known_instances = g_hash_table_new_full ( (GHashFunc) e_cal_component_id_hash, (GEqualFunc) e_cal_component_id_equal, - (GDestroyNotify) e_cal_component_free_id, component_data_free); + (GDestroyNotify) e_cal_component_id_free, component_data_free); for (link = expanded_recurrences; link && view_data->is_used; link = g_slist_next (link)) { ComponentData *comp_data = link->data; - icalcomponent *icomp; + ICalComponent *icomp; const gchar *uid; if (!comp_data) continue; icomp = e_cal_component_get_icalcomponent (comp_data->component); - if (!icomp || !icalcomponent_get_uid (icomp)) + if (!icomp || !i_cal_component_get_uid (icomp)) continue; - uid = icalcomponent_get_uid (icomp); + uid = i_cal_component_get_uid (icomp); if (!g_hash_table_contains (gathered_uids, uid)) { GatherComponentsData gather_data; @@ -1126,27 +1150,79 @@ cal_data_model_notify_recurrences_cb (gpointer user_data) typedef struct { ECalClient *client; - icaltimezone *zone; + ICalTimezone *zone; GSList **pexpanded_recurrences; + gboolean skip_cancelled; } GenerateInstancesData; static gboolean -cal_data_model_instance_generated (ECalComponent *comp, - time_t instance_start, - time_t instance_end, - gpointer data) +cal_data_model_instance_generated (ICalComponent *icomp, + ICalTime *instance_start, + ICalTime *instance_end, + gpointer user_data, + GCancellable *cancellable, + GError **error) { - GenerateInstancesData *gid = data; + GenerateInstancesData *gid = user_data; ComponentData *comp_data; + ECalComponent *comp_copy; + ICalTime *tt, *tt2; + time_t start_tt, end_tt; g_return_val_if_fail (gid != NULL, FALSE); - cal_comp_get_instance_times (gid->client, e_cal_component_get_icalcomponent (comp), - gid->zone, &instance_start, NULL, &instance_end, NULL, NULL); + if (gid->skip_cancelled) { + ICalProperty *prop; - comp_data = component_data_new (comp, instance_start, instance_end, FALSE); + prop = i_cal_component_get_first_property (icomp, I_CAL_STATUS_PROPERTY); + if (prop && i_cal_property_get_status (prop) == I_CAL_STATUS_CANCELLED) { + g_object_unref (prop); + return TRUE; + } + + g_clear_object (&prop); + } + + comp_copy = e_cal_component_new_from_icalcomponent (i_cal_component_clone (icomp)); + g_return_val_if_fail (comp_copy != NULL, FALSE); + + tt = i_cal_component_get_dtstart (e_cal_component_get_icalcomponent (comp_copy)); + tt2 = i_cal_time_convert_to_zone (instance_start, gid->zone); + if (i_cal_time_is_date (tt) || !i_cal_time_get_timezone (tt) || i_cal_time_is_utc (tt)) + i_cal_time_set_timezone (tt2, NULL); + else + i_cal_time_set_timezone (tt2, gid->zone); + i_cal_component_set_dtstart (e_cal_component_get_icalcomponent (comp_copy), tt2); + g_clear_object (&tt); + g_clear_object (&tt2); + + tt = i_cal_component_get_dtend (e_cal_component_get_icalcomponent (comp_copy)); + tt2 = i_cal_time_convert_to_zone (instance_end, gid->zone); + if (i_cal_time_is_date (tt) || !i_cal_time_get_timezone (tt) || i_cal_time_is_utc (tt)) + i_cal_time_set_timezone (tt2, NULL); + else + i_cal_time_set_timezone (tt2, gid->zone); + i_cal_component_set_dtend (e_cal_component_get_icalcomponent (comp_copy), tt2); + g_clear_object (&tt); + g_clear_object (&tt2); + + cal_comp_get_instance_times (gid->client, e_cal_component_get_icalcomponent (comp_copy), + gid->zone, &tt, &tt2, cancellable); + + start_tt = i_cal_time_as_timet (tt); + end_tt = i_cal_time_as_timet (tt2); + + g_clear_object (&tt); + g_clear_object (&tt2); + + if (end_tt > start_tt) + end_tt--; + + comp_data = component_data_new (comp_copy, start_tt, end_tt, FALSE); *gid->pexpanded_recurrences = g_slist_prepend (*gid->pexpanded_recurrences, comp_data); + g_object_unref (comp_copy); + return TRUE; } @@ -1197,7 +1273,7 @@ cal_data_model_expand_recurrences_thread (ECalDataModel *data_model, view_data_unlock (view_data); for (link = to_expand_recurrences; link && view_data->is_used; link = g_slist_next (link)) { - icalcomponent *icomp = link->data; + ICalComponent *icomp = link->data; GenerateInstancesData gid; if (!icomp) @@ -1205,13 +1281,16 @@ cal_data_model_expand_recurrences_thread (ECalDataModel *data_model, gid.client = client; gid.pexpanded_recurrences = &expanded_recurrences; - gid.zone = data_model->priv->zone; + gid.zone = g_object_ref (data_model->priv->zone); + gid.skip_cancelled = data_model->priv->skip_cancelled; - e_cal_client_generate_instances_for_object_sync (client, icomp, range_start, range_end, + e_cal_client_generate_instances_for_object_sync (client, icomp, range_start, range_end, NULL, cal_data_model_instance_generated, &gid); + + g_clear_object (&gid.zone); } - g_slist_free_full (to_expand_recurrences, (GDestroyNotify) icalcomponent_free); + g_slist_free_full (to_expand_recurrences, g_object_unref); view_data_lock (view_data); if (expanded_recurrences) @@ -1245,17 +1324,23 @@ cal_data_model_process_modified_or_added_objects (ECalClientView *view, LOCK_PROPS (); client = e_cal_client_view_ref_client (view); + if (!client) { + UNLOCK_PROPS (); + return; + } + view_data = g_hash_table_lookup (data_model->priv->views, client); if (view_data) { view_data_ref (view_data); g_warn_if_fail (view_data->view == view); } - g_object_unref (client); UNLOCK_PROPS (); - if (!view_data) + if (!view_data) { + g_clear_object (&client); return; + } view_data_lock (view_data); @@ -1277,9 +1362,9 @@ cal_data_model_process_modified_or_added_objects (ECalClientView *view, cal_data_model_freeze_all_subscribers (data_model); for (link = objects; link; link = g_slist_next (link)) { - icalcomponent *icomp = link->data; + ICalComponent *icomp = link->data; - if (!icomp || !icalcomponent_get_uid (icomp)) + if (!icomp || !i_cal_component_get_uid (icomp)) continue; if (data_model->priv->expand_recurrences && @@ -1288,18 +1373,32 @@ cal_data_model_process_modified_or_added_objects (ECalClientView *view, /* This component requires an expand of recurrences, which will be done in a dedicated thread, thus remember it */ to_expand_recurrences = g_slist_prepend (to_expand_recurrences, - icalcomponent_new_clone (icomp)); + i_cal_component_clone (icomp)); } else { /* Single or detached instance, the simple case */ ECalComponent *comp; ComponentData *comp_data; + ICalTime *start_tt = NULL, *end_tt = NULL; time_t instance_start, instance_end; - comp = e_cal_component_new_from_icalcomponent (icalcomponent_new_clone (icomp)); + if (data_model->priv->skip_cancelled && + i_cal_component_get_status (icomp) == I_CAL_STATUS_CANCELLED) + continue; + + comp = e_cal_component_new_from_icalcomponent (i_cal_component_clone (icomp)); if (!comp) continue; - cal_comp_get_instance_times (client, icomp, data_model->priv->zone, &instance_start, NULL, &instance_end, NULL, NULL); + cal_comp_get_instance_times (client, icomp, data_model->priv->zone, &start_tt, &end_tt, NULL); + + instance_start = i_cal_time_as_timet (start_tt); + instance_end = i_cal_time_as_timet (end_tt); + + g_clear_object (&start_tt); + g_clear_object (&end_tt); + + if (instance_end > instance_start) + instance_end--; comp_data = component_data_new (comp, instance_start, instance_end, e_cal_util_component_is_instance (icomp)); @@ -1313,8 +1412,6 @@ cal_data_model_process_modified_or_added_objects (ECalClientView *view, cal_data_model_thaw_all_subscribers (data_model); if (to_expand_recurrences) { - ECalClient *rclient = e_cal_client_view_ref_client (view); - view_data_lock (view_data); view_data->to_expand_recurrences = g_slist_concat ( view_data->to_expand_recurrences, to_expand_recurrences); @@ -1322,12 +1419,14 @@ cal_data_model_process_modified_or_added_objects (ECalClientView *view, view_data_unlock (view_data); cal_data_model_submit_internal_thread_job (data_model, - cal_data_model_expand_recurrences_thread, rclient); + cal_data_model_expand_recurrences_thread, g_object_ref (client)); } } view_data_unlock (view_data); view_data_unref (view_data); + + g_clear_object (&client); } static void @@ -1352,22 +1451,27 @@ cal_data_model_view_objects_removed (ECalClientView *view, ECalDataModel *data_model) { ViewData *view_data; - const GSList *link; ECalClient *client; + const GSList *link; g_return_if_fail (E_IS_CAL_DATA_MODEL (data_model)); LOCK_PROPS (); client = e_cal_client_view_ref_client (view); - view_data = - g_hash_table_lookup (data_model->priv->views, client); + if (!client) { + UNLOCK_PROPS (); + return; + } + + view_data = g_hash_table_lookup (data_model->priv->views, client); + + g_clear_object (&client); if (view_data) { view_data_ref (view_data); g_warn_if_fail (view_data->view == view); } - g_object_unref (client); UNLOCK_PROPS (); @@ -1385,11 +1489,11 @@ cal_data_model_view_objects_removed (ECalClientView *view, const ECalComponentId *id = link->data; if (id) { - if (!id->rid || !*id->rid) { - if (!g_hash_table_contains (gathered_uids, id->uid)) { + if (!e_cal_component_id_get_rid (id)) { + if (!g_hash_table_contains (gathered_uids, e_cal_component_id_get_uid (id))) { GatherComponentsData gather_data; - gather_data.uid = id->uid; + gather_data.uid = e_cal_component_id_get_uid (id); gather_data.pcomponent_ids = &removed; gather_data.component_ids_hash = NULL; gather_data.copy_ids = TRUE; @@ -1401,7 +1505,7 @@ cal_data_model_view_objects_removed (ECalClientView *view, g_hash_table_foreach (view_data->lost_components, cal_data_model_gather_components, &gather_data); - g_hash_table_insert (gathered_uids, id->uid, GINT_TO_POINTER (1)); + g_hash_table_insert (gathered_uids, (gpointer) e_cal_component_id_get_uid (id), GINT_TO_POINTER (1)); } } else { removed = g_list_prepend (removed, e_cal_component_id_copy (id)); @@ -1443,7 +1547,7 @@ cal_data_model_view_objects_removed (ECalClientView *view, cal_data_model_thaw_all_subscribers (data_model); - g_list_free_full (removed, (GDestroyNotify) e_cal_component_free_id); + g_list_free_full (removed, (GDestroyNotify) e_cal_component_id_free); g_hash_table_destroy (gathered_uids); } view_data_unlock (view_data); @@ -1630,11 +1734,8 @@ static void cal_data_model_update_client_view (ECalDataModel *data_model, ECalClient *client) { - /*ESource *source;*/ ViewData *view_data; CreateViewData *cv_data; - /*const gchar *alert_ident; - gchar *description;*/ LOCK_PROPS (); @@ -1696,7 +1797,7 @@ cal_data_model_update_client_view (ECalDataModel *data_model, view_data->lost_components = view_data->components; view_data->components = g_hash_table_new_full ( (GHashFunc) e_cal_component_id_hash, (GEqualFunc) e_cal_component_id_equal, - (GDestroyNotify) e_cal_component_free_id, component_data_free); + (GDestroyNotify) e_cal_component_id_free, component_data_free); } view_data_unlock (view_data); @@ -1706,27 +1807,6 @@ cal_data_model_update_client_view (ECalDataModel *data_model, return; } - /*source = e_client_get_source (E_CLIENT (client)); - - switch (e_cal_client_get_source_type (client)) { - case E_CAL_CLIENT_SOURCE_TYPE_EVENTS: - alert_ident = "calendar:failed-create-view-calendar"; - description = g_strdup_printf (_("Creating view for calendar '%s'"), e_source_get_display_name (source)); - break; - case E_CAL_CLIENT_SOURCE_TYPE_TASKS: - alert_ident = "calendar:failed-create-view-tasks"; - description = g_strdup_printf (_("Creating view for task list '%s'"), e_source_get_display_name (source)); - break; - case E_CAL_CLIENT_SOURCE_TYPE_MEMOS: - alert_ident = "calendar:failed-create-view-memos"; - description = g_strdup_printf (_("Creating view for memo list '%s'"), e_source_get_display_name (source)); - break; - case E_CAL_CLIENT_SOURCE_TYPE_LAST: - g_warn_if_reached (); - UNLOCK_PROPS (); - return; - }*/ - cv_data = g_new0 (CreateViewData, 1); cv_data->data_model = g_object_ref (data_model); cv_data->client = g_object_ref (client); @@ -1735,8 +1815,6 @@ cal_data_model_update_client_view (ECalDataModel *data_model, view_data->cancellable = e_cal_data_model_submit_thread_job (data_model, cal_data_model_create_view_thread, cv_data, create_view_data_free); - /*g_free (description);*/ - UNLOCK_PROPS (); } @@ -1820,8 +1898,8 @@ cal_data_model_add_to_subscriber_except_its_range (ECalDataModel *data_model, /* subs_data should have set the old time range, which means only components which didn't fit into the old time range will be added */ - if (!(instance_start < subs_data->range_end && - instance_end > subs_data->range_start)) + if (!(instance_start <= subs_data->range_end && + instance_end >= subs_data->range_start)) e_cal_data_model_subscriber_component_added (subs_data->subscriber, client, component); return TRUE; @@ -1844,9 +1922,11 @@ cal_data_model_remove_from_subscriber_except_its_range (ECalDataModel *data_mode /* subs_data should have set the new time range, which means only components which don't fit into this new time range will be removed */ - if (!(instance_start < subs_data->range_end && - instance_end > subs_data->range_start)) - e_cal_data_model_subscriber_component_removed (subs_data->subscriber, client, id->uid, id->rid); + if (!(instance_start <= subs_data->range_end && + instance_end >= subs_data->range_start)) + e_cal_data_model_subscriber_component_removed (subs_data->subscriber, client, + e_cal_component_id_get_uid (id), + e_cal_component_id_get_rid (id)); return TRUE; } @@ -1857,7 +1937,7 @@ cal_data_model_set_client_default_zone_cb (gpointer key, gpointer user_data) { ECalClient *client = value; - icaltimezone *zone = user_data; + ICalTimezone *zone = user_data; g_return_if_fail (E_IS_CAL_CLIENT (client)); g_return_if_fail (zone != NULL); @@ -1946,9 +2026,15 @@ cal_data_model_set_property (GObject *object, E_CAL_DATA_MODEL (object), g_value_get_pointer (value)); return; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + + case PROP_SKIP_CANCELLED: + e_cal_data_model_set_skip_cancelled ( + E_CAL_DATA_MODEL (object), + g_value_get_boolean (value)); + return; } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } static void @@ -1971,9 +2057,16 @@ cal_data_model_get_property (GObject *object, e_cal_data_model_get_timezone ( E_CAL_DATA_MODEL (object))); return; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + + case PROP_SKIP_CANCELLED: + g_value_set_boolean ( + value, + e_cal_data_model_get_skip_cancelled ( + E_CAL_DATA_MODEL (object))); + return; } + + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } static void @@ -1998,6 +2091,7 @@ cal_data_model_finalize (GObject *object) g_slist_free_full (data_model->priv->subscribers, subscriber_data_free); g_free (data_model->priv->filter); g_free (data_model->priv->full_filter); + g_clear_object (&data_model->priv->zone); g_rec_mutex_clear (&data_model->priv->props_lock); @@ -2037,6 +2131,16 @@ e_cal_data_model_class_init (ECalDataModelClass *class) NULL, G_PARAM_READWRITE)); + g_object_class_install_property ( + object_class, + PROP_SKIP_CANCELLED, + g_param_spec_boolean ( + "skip-cancelled", + "Skip Cancelled", + NULL, + FALSE, + G_PARAM_READWRITE)); + signals[VIEW_STATE_CHANGED] = g_signal_new ( "view-state-changed", G_TYPE_FROM_CLASS (class), @@ -2063,7 +2167,8 @@ e_cal_data_model_init (ECalDataModel *data_model) data_model->priv->disposing = FALSE; data_model->priv->expand_recurrences = FALSE; - data_model->priv->zone = icaltimezone_get_utc_timezone (); + data_model->priv->skip_cancelled = FALSE; + data_model->priv->zone = g_object_ref (i_cal_timezone_get_utc_timezone ()); data_model->priv->views_update_freeze = 0; data_model->priv->views_update_required = FALSE; @@ -2118,6 +2223,7 @@ e_cal_data_model_new_clone (ECalDataModel *src_data_model) clone = e_cal_data_model_new (src_data_model->priv->submit_thread_job_func); e_cal_data_model_set_expand_recurrences (clone, e_cal_data_model_get_expand_recurrences (src_data_model)); + e_cal_data_model_set_skip_cancelled (clone, e_cal_data_model_get_skip_cancelled (src_data_model)); e_cal_data_model_set_timezone (clone, e_cal_data_model_get_timezone (src_data_model)); e_cal_data_model_set_filter (clone, src_data_model->priv->filter); @@ -2247,6 +2353,62 @@ e_cal_data_model_set_expand_recurrences (ECalDataModel *data_model, UNLOCK_PROPS (); } +/** + * e_cal_data_model_get_skip_cancelled: + * @data_model: an #EDataModel instance + * + * Obtains whether the @data_model skips cancelled components. + * The default value is #FALSE, to not skip cancelled components. + * + * Returns: Whether the @data_model skips cancelled components. + * + * Since: 3.32 + **/ +gboolean +e_cal_data_model_get_skip_cancelled (ECalDataModel *data_model) +{ + gboolean skip_cancelled; + + g_return_val_if_fail (E_IS_CAL_DATA_MODEL (data_model), FALSE); + + LOCK_PROPS (); + + skip_cancelled = data_model->priv->skip_cancelled; + + UNLOCK_PROPS (); + + return skip_cancelled; +} + +/** + * e_cal_data_model_set_skip_cancelled: + * @data_model: an #EDataModel instance + * @skip_cancelled: whether to skip cancelled components + * + * Sets whether the @data_model should skip cancelled components. + * + * Since: 3.32 + **/ +void +e_cal_data_model_set_skip_cancelled (ECalDataModel *data_model, + gboolean skip_cancelled) +{ + g_return_if_fail (E_IS_CAL_DATA_MODEL (data_model)); + + LOCK_PROPS (); + + if ((data_model->priv->skip_cancelled ? 1 : 0) == (skip_cancelled ? 1 : 0)) { + UNLOCK_PROPS (); + return; + } + + data_model->priv->skip_cancelled = skip_cancelled; + + cal_data_model_rebuild_everything (data_model, TRUE); + + UNLOCK_PROPS (); +} + /** * e_cal_data_model_get_timezone: * @data_model: an #EDataModel instance @@ -2254,14 +2416,14 @@ e_cal_data_model_set_expand_recurrences (ECalDataModel *data_model, * Obtains a timezone being used for calendar views. The returned * timezone is owned by the @data_model. * - * Returns: (transfer none): An #icaltimezone being used for calendar views. + * Returns: (transfer none): An #ICalTimezone being used for calendar views. * * Since: 3.14 **/ -icaltimezone * +ICalTimezone * e_cal_data_model_get_timezone (ECalDataModel *data_model) { - icaltimezone *zone; + ICalTimezone *zone; g_return_val_if_fail (E_IS_CAL_DATA_MODEL (data_model), NULL); @@ -2273,10 +2435,11 @@ e_cal_data_model_get_timezone (ECalDataModel *data_model) return zone; } + /** * e_cal_data_model_set_timezone: * @data_model: an #EDataModel instance - * @zone: an #icaltimezone + * @zone: an #ICalTimezone * * Sets a trimezone to be used for calendar views. This change * regenerates all views. @@ -2285,7 +2448,7 @@ e_cal_data_model_get_timezone (ECalDataModel *data_model) **/ void e_cal_data_model_set_timezone (ECalDataModel *data_model, - icaltimezone *zone) + ICalTimezone *zone) { g_return_if_fail (E_IS_CAL_DATA_MODEL (data_model)); g_return_if_fail (zone != NULL); @@ -2293,7 +2456,8 @@ e_cal_data_model_set_timezone (ECalDataModel *data_model, LOCK_PROPS (); if (data_model->priv->zone != zone) { - data_model->priv->zone = zone; + g_clear_object (&data_model->priv->zone); + data_model->priv->zone = g_object_ref (zone); g_hash_table_foreach (data_model->priv->clients, cal_data_model_set_client_default_zone_cb, zone); @@ -2603,8 +2767,8 @@ cal_data_model_foreach_component (ECalDataModel *data_model, continue; if ((in_range_start == in_range_end && in_range_start == (time_t) 0) || - (comp_data->instance_start < in_range_end && - comp_data->instance_end > in_range_start)) { + (comp_data->instance_start < in_range_end && comp_data->instance_end > in_range_start) || + (comp_data->instance_start == comp_data->instance_end && comp_data->instance_end == in_range_start)) { if (!func (data_model, view_data->client, id, comp_data->component, comp_data->instance_start, comp_data->instance_end, user_data)) checked_all = FALSE; @@ -2621,8 +2785,8 @@ cal_data_model_foreach_component (ECalDataModel *data_model, continue; if ((in_range_start == in_range_end && in_range_start == (time_t) 0) || - (comp_data->instance_start < in_range_end && - comp_data->instance_end > in_range_start)) { + (comp_data->instance_start < in_range_end && comp_data->instance_end > in_range_start) || + (comp_data->instance_start == comp_data->instance_end && comp_data->instance_end == in_range_start)) { if (!func (data_model, view_data->client, id, comp_data->component, comp_data->instance_start, comp_data->instance_end, user_data)) checked_all = FALSE; @@ -2711,7 +2875,7 @@ e_cal_data_model_subscribe (ECalDataModel *data_model, LOCK_PROPS (); for (link = data_model->priv->subscribers; link; link = g_slist_next (link)) { - subs_data = link->data; + SubscriberData *subs_data = link->data; if (!subs_data) continue; diff --git a/contrib/evolution/e-cal-data-model.h b/contrib/evolution/e-cal-data-model.h index 5ddea296..ba79c4de 100644 --- a/contrib/evolution/e-cal-data-model.h +++ b/contrib/evolution/e-cal-data-model.h @@ -96,9 +96,14 @@ gboolean e_cal_data_model_get_expand_recurrences void e_cal_data_model_set_expand_recurrences (ECalDataModel *data_model, gboolean expand_recurrences); -icaltimezone * e_cal_data_model_get_timezone (ECalDataModel *data_model); +gboolean e_cal_data_model_get_skip_cancelled + (ECalDataModel *data_model); +void e_cal_data_model_set_skip_cancelled + (ECalDataModel *data_model, + gboolean expand_recurrences); +ICalTimezone * e_cal_data_model_get_timezone (ECalDataModel *data_model); void e_cal_data_model_set_timezone (ECalDataModel *data_model, - icaltimezone *zone); + ICalTimezone *zone); void e_cal_data_model_set_filter (ECalDataModel *data_model, const gchar *sexp); gchar * e_cal_data_model_dup_filter (ECalDataModel *data_model); diff --git a/meson.build b/meson.build index 01005f9f..43916662 100644 --- a/meson.build +++ b/meson.build @@ -139,7 +139,7 @@ assert(cc.has_function('icaltime_days_in_year', dependencies: libical_dep), gsettings_desktop_schemas_dep = dependency('gsettings-desktop-schemas', version: '>= 3.21.2') libedataserverui_dep = dependency('libedataserverui-1.2', version: '>= 3.17.1') libedataserver_dep = dependency('libedataserver-1.2', version: '>= 3.17.1') -libecal_dep = dependency('libecal-1.2', version: '>= 3.13.90') +libecal_dep = dependency('libecal-2.0', version: '>= 3.33.2') libsoup_dep = dependency('libsoup-2.4') libdazzle_dep = dependency('libdazzle-1.0', version: '>= 3.33.1') glib_dep = dependency('glib-2.0', version: '>= 2.58.0') diff --git a/src/core/gcal-event.c b/src/core/gcal-event.c index 24108d76..ef16bf04 100644 --- a/src/core/gcal-event.c +++ b/src/core/gcal-event.c @@ -75,6 +75,10 @@ struct _GcalEvent gchar *uid; gboolean has_recurrence; + /* These are cached, because ECalComponent returns newly allocated data for them */ + gchar *summary; + gchar *location; + /* * The description is cached in the class because it * may come as a GSList of descriptions, in which @@ -167,12 +171,14 @@ destroy_event_cache_map (void) static GTimeZone* get_timezone_from_ical (ECalComponentDateTime *comp) { - const icaltimezone *zone; + ICalTimezone *zone; + ICalTime *itt; GTimeZone *tz; - zone = icaltime_get_timezone (*comp->value); + itt = e_cal_component_datetime_get_value (comp); + zone = i_cal_time_get_timezone (itt); - if (comp->value->is_date) + if (i_cal_time_is_date (itt)) { /* * When loading an all day event, the timezone must not be taken into account @@ -181,13 +187,13 @@ get_timezone_from_ical (ECalComponentDateTime *comp) */ tz = g_time_zone_new_utc (); } - else if (comp->tzid) + else if (e_cal_component_datetime_get_tzid (comp)) { const gchar *real_tzid; - real_tzid = comp->tzid; + real_tzid = e_cal_component_datetime_get_tzid (comp); - if (g_str_has_prefix (comp->tzid, LIBICAL_TZID_PREFIX)) + if (g_str_has_prefix (real_tzid, LIBICAL_TZID_PREFIX)) real_tzid += strlen (LIBICAL_TZID_PREFIX); tz = g_time_zone_new (real_tzid); @@ -197,8 +203,7 @@ get_timezone_from_ical (ECalComponentDateTime *comp) g_autofree gchar *tzid = NULL; gint offset; - offset = icaltimezone_get_utc_offset ((icaltimezone*) icaltime_get_timezone (*comp->value), - comp->value, NULL); + offset = i_cal_timezone_get_utc_offset (zone, itt, NULL); tzid = format_utc_offset (offset); tz = g_time_zone_new (tzid); } @@ -218,27 +223,32 @@ static ECalComponentDateTime* build_component_from_datetime (GcalEvent *self, GDateTime *dt) { - ECalComponentDateTime *comp_dt; + ICalTime *itt; + gchar *tzid; if (!dt) return NULL; - comp_dt = g_new0 (ECalComponentDateTime, 1); - comp_dt->value = gcal_date_time_to_icaltime (dt); - comp_dt->value->is_date = self->all_day; + itt = gcal_date_time_to_icaltime (dt); if (self->all_day) { - comp_dt->value->zone = icaltimezone_get_utc_timezone (); - comp_dt->tzid = g_strdup ("UTC"); + i_cal_time_set_timezone (itt, i_cal_timezone_get_utc_timezone ()); + tzid = g_strdup ("UTC"); } else { - comp_dt->value->zone = e_cal_util_get_system_timezone (); - comp_dt->tzid = g_strdup (icaltimezone_get_tzid ((icaltimezone *) comp_dt->value->zone)); + ICalTimezone *zone; + + zone = e_cal_util_get_system_timezone (); + i_cal_time_set_timezone (itt, zone); + tzid = zone ? g_strdup (i_cal_timezone_get_tzid (zone)) : NULL; } - return comp_dt; + /* Call it after setting the timezone, because the DATE values do not let set the timezone */ + i_cal_time_set_is_date (itt, self->all_day); + + return e_cal_component_datetime_new_take (itt, tzid); } static void @@ -254,28 +264,28 @@ gcal_event_update_uid_internal (GcalEvent *self) /* Clear the previous uid */ g_clear_pointer (&self->uid, g_free); - if (id->rid != NULL) + if (e_cal_component_id_get_rid (id) != NULL) { self->uid = g_strdup_printf ("%s:%s:%s", source_id, - id->uid, - id->rid); + e_cal_component_id_get_uid (id), + e_cal_component_id_get_rid (id)); } else { self->uid = g_strdup_printf ("%s:%s", source_id, - id->uid); + e_cal_component_id_get_uid (id)); } - e_cal_component_free_id (id); + e_cal_component_id_free (id); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_UID]); } static void load_alarms (GcalEvent *self) { - GList *alarm_uids, *l; + GSList *alarm_uids, *l; alarm_uids = e_cal_component_get_alarm_uids (self->component); @@ -298,7 +308,7 @@ load_alarms (GcalEvent *self) e_cal_component_alarm_free (alarm); } - cal_obj_uid_list_free (alarm_uids); + g_slist_free_full (alarm_uids, g_free); } static void @@ -307,24 +317,25 @@ gcal_event_set_component_internal (GcalEvent *self, { if (g_set_object (&self->component, component)) { - ECalComponentDateTime start; - ECalComponentDateTime end; - icaltimetype date; + ECalComponentDateTime *start; + ECalComponentDateTime *end; + ECalComponentText *text; + ICalTime *date; GDateTime *date_start; GTimeZone *zone_start = NULL; GDateTime *date_end; GTimeZone *zone_end = NULL; gboolean start_is_all_day, end_is_all_day; - gchar *description; + gchar *description, *location; /* Setup start date */ - e_cal_component_get_dtstart (component, &start); + start = e_cal_component_get_dtstart (component); /* * A NULL start date is invalid. We set something bogus to proceed, and make * it set a GError and return NULL. */ - if (!start.value) + if (!start || !e_cal_component_datetime_get_value (start)) { self->is_valid = FALSE; g_set_error (&self->initialization_error, @@ -332,27 +343,31 @@ gcal_event_set_component_internal (GcalEvent *self, GCAL_EVENT_ERROR_INVALID_START_DATE, "Event '%s' has an invalid start date", gcal_event_get_uid (self)); - start.value = g_new0 (icaltimetype, 1); - *start.value = icaltime_today (); + e_cal_component_datetime_free (start); + start = e_cal_component_datetime_new_take (i_cal_time_new_today (), NULL); } GCAL_TRACE_MSG ("Retrieving start timezone"); - date = icaltime_normalize (*start.value); - zone_start = get_timezone_from_ical (&start); + date = i_cal_time_normalize (e_cal_component_datetime_get_value (start)); + zone_start = get_timezone_from_ical (start); date_start = g_date_time_new (zone_start, - date.year, date.month, date.day, - date.is_date ? 0 : date.hour, - date.is_date ? 0 : date.minute, - date.is_date ? 0 : date.second); + i_cal_time_get_year (date), + i_cal_time_get_month (date), + i_cal_time_get_day (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_hour (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_minute (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_second (date)); start_is_all_day = gcal_date_time_is_date (date_start); self->dt_start = date_start; - /* Setup end date */ - e_cal_component_get_dtend (component, &end); + g_clear_object (&date); - if(!end.value) + /* Setup end date */ + end = e_cal_component_get_dtend (component); + + if (!end || !e_cal_component_datetime_get_value (end)) { self->all_day = TRUE; } @@ -360,13 +375,15 @@ gcal_event_set_component_internal (GcalEvent *self, { GCAL_TRACE_MSG ("Retrieving end timezone"); - date = icaltime_normalize (*end.value); - zone_end = get_timezone_from_ical (&end); + date = i_cal_time_normalize (e_cal_component_datetime_get_value (end)); + zone_end = get_timezone_from_ical (end); date_end = g_date_time_new (zone_end, - date.year, date.month, date.day, - date.is_date ? 0 : date.hour, - date.is_date ? 0 : date.minute, - date.is_date ? 0 : date.second); + i_cal_time_get_year (date), + i_cal_time_get_month (date), + i_cal_time_get_day (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_hour (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_minute (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_second (date)); end_is_all_day = gcal_date_time_is_date (date_end); self->dt_end = g_date_time_ref (date_end); @@ -374,9 +391,20 @@ gcal_event_set_component_internal (GcalEvent *self, /* Setup all day */ self->all_day = start_is_all_day && end_is_all_day; - e_cal_component_free_datetime (&end); + g_clear_object (&date); } + /* Summary */ + text = e_cal_component_get_summary (component); + if (text && e_cal_component_text_get_value (text)) + gcal_event_set_summary (self, e_cal_component_text_get_value (text)); + else + gcal_event_set_summary (self, ""); + + /* Location */ + location = e_cal_component_get_location (component); + gcal_event_set_location (self, location ? location : ""); + /* Setup description */ description = get_desc_from_component (component, "\n\n"); gcal_event_set_description (self, description); @@ -396,14 +424,15 @@ gcal_event_set_component_internal (GcalEvent *self, g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_HAS_RECURRENCE]); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_RECURRENCE]); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_COMPONENT]); - g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LOCATION]); - g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SUMMARY]); g_clear_pointer (&zone_start, g_time_zone_unref); g_clear_pointer (&zone_end, g_time_zone_unref); g_clear_pointer (&description, g_free); + g_clear_pointer (&location, g_free); - e_cal_component_free_datetime (&start); + e_cal_component_text_free (text); + e_cal_component_datetime_free (start); + e_cal_component_datetime_free (end); } } @@ -449,6 +478,8 @@ gcal_event_finalize (GObject *object) g_clear_pointer (&self->dt_start, g_date_time_unref); g_clear_pointer (&self->dt_end, g_date_time_unref); + g_clear_pointer (&self->summary, g_free); + g_clear_pointer (&self->location, g_free); g_clear_pointer (&self->description, g_free); g_clear_pointer (&self->alarms, g_hash_table_unref); g_clear_pointer (&self->uid, g_free); @@ -937,8 +968,7 @@ gcal_event_set_date_end (GcalEvent *self, g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DATE_END]); - e_cal_component_free_datetime (component_dt); - g_free (component_dt); + e_cal_component_datetime_free (component_dt); } } @@ -986,8 +1016,7 @@ gcal_event_set_date_start (GcalEvent *self, g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DATE_START]); - e_cal_component_free_datetime (component_dt); - g_free (component_dt); + e_cal_component_datetime_free (component_dt); } } @@ -1020,21 +1049,32 @@ gcal_event_set_description (GcalEvent *self, { g_return_if_fail (GCAL_IS_EVENT (self)); + if (description && !*description) + description = NULL; + if (g_strcmp0 (self->description, description) != 0) { - ECalComponentText text_component; - GSList list; - g_clear_pointer (&self->description, g_free); self->description = g_strdup (description); - text_component.value = description; - text_component.altrep = NULL; + if (description) + { + ECalComponentText* text_component; + GSList list; - list.data = &text_component; - list.next = NULL; + text_component = e_cal_component_text_new (description, NULL); + + list.data = text_component; + list.next = NULL; + + e_cal_component_set_descriptions (self->component, &list); + e_cal_component_text_free (text_component); + } + else + { + e_cal_component_set_descriptions (self->component, NULL); + } - e_cal_component_set_description_list (self->component, &list); e_cal_component_commit_sequence (self->component); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_DESCRIPTION]); @@ -1085,7 +1125,8 @@ GList* gcal_event_get_alarms (GcalEvent *self) { GHashTable *tmp; - GList *alarm_uids, *alarms, *l; + GSList *alarm_uids, *l; + GList *alarms; g_return_val_if_fail (GCAL_IS_EVENT (self), NULL); @@ -1114,7 +1155,7 @@ gcal_event_get_alarms (GcalEvent *self) } } - cal_obj_uid_list_free (alarm_uids); + g_slist_free_full (alarm_uids, g_free); g_hash_table_destroy (tmp); return alarms; @@ -1136,9 +1177,10 @@ gcal_event_add_alarm (GcalEvent *self, guint type, gboolean has_sound) { - ECalComponentAlarmTrigger trigger; + ECalComponentAlarmTrigger *trigger; ECalComponentAlarmAction action; ECalComponentAlarm *alarm; + ICalDuration *duration; gchar *alarm_uid; g_return_if_fail (GCAL_IS_EVENT (self)); @@ -1155,13 +1197,15 @@ gcal_event_add_alarm (GcalEvent *self, alarm = e_cal_component_alarm_new (); /* Setup the alarm trigger */ - trigger.type = E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START; + duration = i_cal_duration_new_null_duration (); + i_cal_duration_set_is_neg (duration, TRUE); + i_cal_duration_set_minutes (duration, type); - trigger.u.rel_duration = icaldurationtype_null_duration (); - trigger.u.rel_duration.is_neg = TRUE; - trigger.u.rel_duration.minutes = type; + trigger = e_cal_component_alarm_trigger_new_relative (E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START, duration); - e_cal_component_alarm_set_trigger (alarm, trigger); + g_clear_object (&duration); + + e_cal_component_alarm_take_trigger (alarm, trigger); /* Action */ if (has_sound) @@ -1223,13 +1267,9 @@ gcal_event_remove_alarm (GcalEvent *self, const gchar* gcal_event_get_location (GcalEvent *self) { - const gchar *location; - g_return_val_if_fail (GCAL_IS_EVENT (self), NULL); - e_cal_component_get_location (self->component, &location); - - return location ? location : ""; + return self->location; } /** @@ -1251,7 +1291,10 @@ gcal_event_set_location (GcalEvent *self, if (g_strcmp0 (current_location, location) != 0) { - e_cal_component_set_location (self->component, location); + e_cal_component_set_location (self->component, (location && *location) ? location : NULL); + + g_clear_pointer (&self->location, g_free); + self->location = g_strdup (location ? location : ""); g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LOCATION]); } @@ -1321,13 +1364,9 @@ gcal_event_set_calendar (GcalEvent *self, const gchar* gcal_event_get_summary (GcalEvent *self) { - ECalComponentText summary; - g_return_val_if_fail (GCAL_IS_EVENT (self), NULL); - e_cal_component_get_summary (self->component, &summary); - - return summary.value ? summary.value : ""; + return self->summary; } /** @@ -1349,14 +1388,18 @@ gcal_event_set_summary (GcalEvent *self, if (g_strcmp0 (current_summary, summary) != 0) { - ECalComponentText text_component; + ECalComponentText *text_component; - text_component.value = summary ? summary : ""; - text_component.altrep = NULL; + text_component = e_cal_component_text_new (summary ? summary : "", NULL); - e_cal_component_set_summary (self->component, &text_component); + e_cal_component_set_summary (self->component, text_component); e_cal_component_commit_sequence (self->component); + e_cal_component_text_free (text_component); + + g_clear_pointer (&self->summary, g_free); + self->summary = g_strdup (summary ? summary : ""); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SUMMARY]); } } @@ -1552,9 +1595,9 @@ gcal_event_set_recurrence (GcalEvent *self, GcalRecurrence *recur) { ECalComponent *comp; - icalcomponent *icalcomp; - icalproperty *prop; - struct icalrecurrencetype *rrule; + ICalComponent *icalcomp; + ICalProperty *prop; + ICalRecurrence *rrule; g_return_if_fail (GCAL_IS_EVENT (self)); @@ -1566,20 +1609,20 @@ gcal_event_set_recurrence (GcalEvent *self, g_clear_pointer (&self->recurrence, gcal_recurrence_unref); self->recurrence = gcal_recurrence_copy (recur); - prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); + prop = i_cal_component_get_first_property (icalcomp, I_CAL_RRULE_PROPERTY); if (prop) { - icalproperty_set_rrule (prop, *rrule); + i_cal_property_set_rrule (prop, rrule); } else { - prop = icalproperty_new_rrule (*rrule); - icalcomponent_add_property (icalcomp, prop); + prop = i_cal_property_new_rrule (rrule); + i_cal_component_add_property (icalcomp, prop); } - /* Rescan the component for the changes to be detected and registered */ - e_cal_component_rescan (comp); + g_clear_object (&rrule); + g_clear_object (&prop); } /** @@ -1619,33 +1662,36 @@ gcal_event_get_original_timezones (GcalEvent *self, { g_autoptr (GTimeZone) original_start_tz = NULL; g_autoptr (GTimeZone) original_end_tz = NULL; - icalcomponent *ical_comp; - icalproperty *property; + ICalComponent *icalcomp; + ICalProperty *property; g_return_if_fail (GCAL_IS_EVENT (self)); g_assert (self->component != NULL); - ical_comp = e_cal_component_get_icalcomponent (self->component); + icalcomp = e_cal_component_get_icalcomponent (self->component); - for (property = icalcomponent_get_first_property (ical_comp, ICAL_X_PROPERTY); + for (property = i_cal_component_get_first_property (icalcomp, I_CAL_X_PROPERTY); property; - property = icalcomponent_get_next_property (ical_comp, ICAL_X_PROPERTY)) + g_object_unref (property), property = i_cal_component_get_next_property (icalcomp, I_CAL_X_PROPERTY)) { const gchar *value; if (original_start_tz && original_end_tz) - break; - - if (g_strcmp0 (icalproperty_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-START") == 0) { - value = icalproperty_get_x (property); + g_object_unref (property); + break; + } + + if (g_strcmp0 (i_cal_property_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-START") == 0) + { + value = i_cal_property_get_x (property); original_start_tz = g_time_zone_new (value); GCAL_TRACE_MSG ("Found X-GNOME-CALENDAR-ORIGINAL-TZ-START=%s", value); } - else if (g_strcmp0 (icalproperty_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-END") == 0) + else if (g_strcmp0 (i_cal_property_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-END") == 0) { - value = icalproperty_get_x (property); + value = i_cal_property_get_x (property); original_end_tz = g_time_zone_new (value); GCAL_TRACE_MSG ("Found X-GNOME-CALENDAR-ORIGINAL-TZ-END=%s", value); @@ -1680,8 +1726,8 @@ gcal_event_get_original_timezones (GcalEvent *self, void gcal_event_save_original_timezones (GcalEvent *self) { - icalcomponent *ical_comp; - icalproperty *property; + ICalComponent *icalcomp; + ICalProperty *property; GTimeZone *tz; gboolean has_original_start_tz; gboolean has_original_end_tz; @@ -1693,52 +1739,54 @@ gcal_event_save_original_timezones (GcalEvent *self) has_original_start_tz = FALSE; has_original_end_tz = FALSE; - ical_comp = e_cal_component_get_icalcomponent (self->component); + icalcomp = e_cal_component_get_icalcomponent (self->component); - for (property = icalcomponent_get_first_property (ical_comp, ICAL_X_PROPERTY); - property; - property = icalcomponent_get_next_property (ical_comp, ICAL_X_PROPERTY)) + for (property = i_cal_component_get_first_property (icalcomp, I_CAL_X_PROPERTY); + property && (!has_original_start_tz || !has_original_end_tz); + g_object_unref (property), property = i_cal_component_get_next_property (icalcomp, I_CAL_X_PROPERTY)) { - if (g_strcmp0 (icalproperty_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-START") == 0) + if (g_strcmp0 (i_cal_property_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-START") == 0) { tz = g_date_time_get_timezone (self->dt_start); - icalproperty_set_x (property, g_time_zone_get_identifier (tz)); + i_cal_property_set_x (property, g_time_zone_get_identifier (tz)); - GCAL_TRACE_MSG ("Reusing X-GNOME-CALENDAR-ORIGINAL-TZ-START property with %s", icalproperty_get_x (property)); + GCAL_TRACE_MSG ("Reusing X-GNOME-CALENDAR-ORIGINAL-TZ-START property with %s", i_cal_property_get_x (property)); has_original_start_tz = TRUE; } - else if (g_strcmp0 (icalproperty_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-END") == 0) + else if (g_strcmp0 (i_cal_property_get_x_name (property), "X-GNOME-CALENDAR-ORIGINAL-TZ-END") == 0) { tz = g_date_time_get_timezone (self->dt_end); - icalproperty_set_x (property, g_time_zone_get_identifier (tz)); + i_cal_property_set_x (property, g_time_zone_get_identifier (tz)); - GCAL_TRACE_MSG ("Reusing X-GNOME-CALENDAR-ORIGINAL-TZ-END property with %s", icalproperty_get_x (property)); + GCAL_TRACE_MSG ("Reusing X-GNOME-CALENDAR-ORIGINAL-TZ-END property with %s", i_cal_property_get_x (property)); has_original_end_tz = TRUE; } } + g_clear_object (&property); + if (!has_original_start_tz) { tz = g_date_time_get_timezone (self->dt_start); - property = icalproperty_new_x (g_time_zone_get_identifier (tz)); - icalproperty_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-START"); + property = i_cal_property_new_x (g_time_zone_get_identifier (tz)); + i_cal_property_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-START"); - icalcomponent_add_property (ical_comp, property); + GCAL_TRACE_MSG ("Added new X-GNOME-CALENDAR-ORIGINAL-TZ-START property with %s", i_cal_property_get_x (property)); - GCAL_TRACE_MSG ("Added new X-GNOME-CALENDAR-ORIGINAL-TZ-START property with %s", icalproperty_get_x (property)); + i_cal_component_take_property (icalcomp, property); } if (!has_original_end_tz) { tz = g_date_time_get_timezone (self->dt_end); - property = icalproperty_new_x (g_time_zone_get_identifier (tz)); - icalproperty_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-END"); + property = i_cal_property_new_x (g_time_zone_get_identifier (tz)); + i_cal_property_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-END"); - icalcomponent_add_property (ical_comp, property); + GCAL_TRACE_MSG ("Added new X-GNOME-CALENDAR-ORIGINAL-TZ-END property with %s", i_cal_property_get_x (property)); - GCAL_TRACE_MSG ("Added new X-GNOME-CALENDAR-ORIGINAL-TZ-END property with %s", icalproperty_get_x (property)); + i_cal_component_take_property (icalcomp, property); } GCAL_EXIT; diff --git a/src/core/gcal-manager.c b/src/core/gcal-manager.c index 7c0b7d78..51619906 100644 --- a/src/core/gcal-manager.c +++ b/src/core/gcal-manager.c @@ -1193,7 +1193,7 @@ void gcal_manager_create_event (GcalManager *self, GcalEvent *event) { - icalcomponent *new_event_icalcomp; + ICalComponent *new_event_icalcomp; ECalComponent *component; GcalCalendar *calendar; AsyncOpsData *data; @@ -1214,6 +1214,7 @@ gcal_manager_create_event (GcalManager *self, e_cal_client_create_object (gcal_calendar_get_client (calendar), new_event_icalcomp, + E_CAL_OPERATION_FLAG_NONE, self->async_ops, on_event_created, data); @@ -1264,6 +1265,7 @@ gcal_manager_update_event (GcalManager *self, e_cal_client_modify_object (gcal_calendar_get_client (calendar), e_cal_component_get_icalcomponent (component), (ECalObjModType) mod, + E_CAL_OPERATION_FLAG_NONE, NULL, on_event_updated, component); @@ -1298,7 +1300,7 @@ gcal_manager_remove_event (GcalManager *self, calendar = gcal_event_get_calendar (event); rid = NULL; - e_cal_component_get_uid (component, &uid); + uid = e_cal_component_get_uid (component); if (gcal_event_has_recurrence (event)) rid = e_cal_component_get_recurid_as_string (component); @@ -1307,6 +1309,7 @@ gcal_manager_remove_event (GcalManager *self, uid, mod == GCAL_RECURRENCE_MOD_ALL ? NULL : rid, (ECalObjModType) mod, + E_CAL_OPERATION_FLAG_NONE, self->async_ops, on_event_removed, g_object_ref (event)); @@ -1333,7 +1336,7 @@ gcal_manager_move_event_to_source (GcalManager *self, { ECalComponent *ecomponent; ECalComponent *clone; - icalcomponent *comp; + ICalComponent *comp; GcalCalendar *calendar; ECalComponentId *id; GError *error; @@ -1355,6 +1358,7 @@ gcal_manager_move_event_to_source (GcalManager *self, e_cal_client_create_object_sync (gcal_calendar_get_client (calendar), comp, + E_CAL_OPERATION_FLAG_NONE, NULL, NULL, &error); @@ -1377,9 +1381,10 @@ gcal_manager_move_event_to_source (GcalManager *self, id = e_cal_component_get_id (ecomponent); e_cal_client_remove_object_sync (gcal_calendar_get_client (calendar), - id->uid, - id->rid, + e_cal_component_id_get_uid (id), + e_cal_component_id_get_rid (id), E_CAL_OBJ_MOD_THIS, + E_CAL_OPERATION_FLAG_NONE, self->async_ops, &error); @@ -1391,7 +1396,7 @@ gcal_manager_move_event_to_source (GcalManager *self, return; } - e_cal_component_free_id (id); + e_cal_component_id_free (id); GCAL_EXIT; } @@ -1409,9 +1414,9 @@ gcal_manager_move_event_to_source (GcalManager *self, * Returns: (nullable)(transfer full)(content-type GcalEvent):a #GList */ GList* -gcal_manager_get_events (GcalManager *self, - icaltimetype *start_date, - icaltimetype *end_date) +gcal_manager_get_events (GcalManager *self, + ICalTime *start_date, + ICalTime *end_date) { time_t range_start, range_end; GatherEventData data = { @@ -1423,8 +1428,8 @@ gcal_manager_get_events (GcalManager *self, g_return_val_if_fail (GCAL_IS_MANAGER (self), NULL); - range_start = icaltime_as_timet_with_zone (*start_date, e_cal_util_get_system_timezone ()); - range_end = icaltime_as_timet_with_zone (*end_date, e_cal_util_get_system_timezone ()); + range_start = i_cal_time_as_timet_with_zone (start_date, e_cal_util_get_system_timezone ()); + range_end = i_cal_time_as_timet_with_zone (end_date, e_cal_util_get_system_timezone ()); e_cal_data_model_foreach_component (self->e_data_model, range_start, diff --git a/src/core/gcal-manager.h b/src/core/gcal-manager.h index 48a5b43e..0874372e 100644 --- a/src/core/gcal-manager.h +++ b/src/core/gcal-manager.h @@ -23,7 +23,7 @@ #include "gcal-calendar.h" #include "gcal-event.h" -#include +#include G_BEGIN_DECLS @@ -88,8 +88,8 @@ void gcal_manager_save_source (GcalManager ESource *source); GList* gcal_manager_get_events (GcalManager *self, - icaltimetype *range_start, - icaltimetype *range_end); + ICalTime *range_start, + ICalTime *range_end); /* GNOME Shell-related functions */ GcalEvent* gcal_manager_get_event_from_shell_search (GcalManager *self, diff --git a/src/core/gcal-recurrence.c b/src/core/gcal-recurrence.c index 391e59fb..ca9316d9 100644 --- a/src/core/gcal-recurrence.c +++ b/src/core/gcal-recurrence.c @@ -160,9 +160,9 @@ GcalRecurrence* gcal_recurrence_parse_recurrence_rules (ECalComponent *comp) { GcalRecurrence *recur; - icalproperty *prop; - icalcomponent *icalcomp; - struct icalrecurrencetype rrule; + ICalProperty *prop; + ICalComponent *icalcomp; + ICalRecurrence *rrule; if (!e_cal_component_has_recurrences (comp)) return NULL; @@ -170,26 +170,28 @@ gcal_recurrence_parse_recurrence_rules (ECalComponent *comp) recur = gcal_recurrence_new (); icalcomp = e_cal_component_get_icalcomponent (comp); - prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); + prop = i_cal_component_get_first_property (icalcomp, I_CAL_RRULE_PROPERTY); g_return_val_if_fail (prop != NULL, NULL); - rrule = icalproperty_get_rrule (prop); + rrule = i_cal_property_get_rrule (prop); - switch (rrule.freq) + g_clear_object (&prop); + + switch (i_cal_recurrence_get_freq (rrule)) { - case ICAL_DAILY_RECURRENCE: + case I_CAL_DAILY_RECURRENCE: recur->frequency = GCAL_RECURRENCE_DAILY; break; - case ICAL_WEEKLY_RECURRENCE: + case I_CAL_WEEKLY_RECURRENCE: { - if (rrule.by_day[0] == ICAL_MONDAY_WEEKDAY && - rrule.by_day[1] == ICAL_TUESDAY_WEEKDAY && - rrule.by_day[2] == ICAL_WEDNESDAY_WEEKDAY && - rrule.by_day[3] == ICAL_THURSDAY_WEEKDAY && - rrule.by_day[4] == ICAL_FRIDAY_WEEKDAY && - rrule.by_day[5] != ICAL_SATURDAY_WEEKDAY && - rrule.by_day[6] != ICAL_SUNDAY_WEEKDAY) + if (i_cal_recurrence_get_by_day (rrule, 0) == I_CAL_MONDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 1) == I_CAL_TUESDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 2) == I_CAL_WEDNESDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 3) == I_CAL_THURSDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 4) == I_CAL_FRIDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 5) != I_CAL_SATURDAY_WEEKDAY && + i_cal_recurrence_get_by_day (rrule, 6) != I_CAL_SUNDAY_WEEKDAY) { recur->frequency = GCAL_RECURRENCE_MON_FRI; } @@ -200,11 +202,11 @@ gcal_recurrence_parse_recurrence_rules (ECalComponent *comp) break; } - case ICAL_MONTHLY_RECURRENCE: + case I_CAL_MONTHLY_RECURRENCE: recur->frequency = GCAL_RECURRENCE_MONTHLY; break; - case ICAL_YEARLY_RECURRENCE: + case I_CAL_YEARLY_RECURRENCE: recur->frequency = GCAL_RECURRENCE_YEARLY; break; @@ -212,21 +214,32 @@ gcal_recurrence_parse_recurrence_rules (ECalComponent *comp) recur->frequency = GCAL_RECURRENCE_OTHER; } - if (rrule.count > 0) + if (i_cal_recurrence_get_count (rrule) > 0) { recur->limit_type = GCAL_RECURRENCE_COUNT; - recur->limit.count = rrule.count; - } - else if (rrule.until.year != 0) - { - recur->limit_type = GCAL_RECURRENCE_UNTIL; - recur->limit.until = gcal_date_time_from_icaltime (&rrule.until); + recur->limit.count = i_cal_recurrence_get_count (rrule); } else { - recur->limit_type = GCAL_RECURRENCE_FOREVER; + ICalTime *until; + + until = i_cal_recurrence_get_until (rrule); + + if (i_cal_time_get_year (until) != 0) + { + recur->limit_type = GCAL_RECURRENCE_UNTIL; + recur->limit.until = gcal_date_time_from_icaltime (until); + } + else + { + recur->limit_type = GCAL_RECURRENCE_FOREVER; + } + + g_clear_object (&until); } + g_clear_object (&rrule); + return recur; } @@ -236,72 +249,80 @@ gcal_recurrence_parse_recurrence_rules (ECalComponent *comp) * * Converts @recur into corresponding rrule. * - * Returns: (transfer full): a #struct icalrecurrencetype + * Returns: (transfer full): an #ICalRecurrence */ -struct icalrecurrencetype* +ICalRecurrence* gcal_recurrence_to_rrule (GcalRecurrence *recur) { - struct icalrecurrencetype *rrule; + ICalRecurrence *rrule; if (!recur) return NULL; /* Initialize and clear the rrule to get rid of unwanted fields */ - rrule = g_new0 (struct icalrecurrencetype, 1); - icalrecurrencetype_clear (rrule); + rrule = i_cal_recurrence_new (); switch (recur->frequency) { case GCAL_RECURRENCE_DAILY: - rrule->freq = ICAL_DAILY_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_DAILY_RECURRENCE); break; case GCAL_RECURRENCE_WEEKLY: - rrule->freq = ICAL_WEEKLY_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_WEEKLY_RECURRENCE); break; case GCAL_RECURRENCE_MONTHLY: - rrule->freq = ICAL_MONTHLY_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_MONTHLY_RECURRENCE); break; case GCAL_RECURRENCE_YEARLY: - rrule->freq = ICAL_YEARLY_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_YEARLY_RECURRENCE); break; case GCAL_RECURRENCE_NO_REPEAT: - rrule->freq = ICAL_NO_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_NO_RECURRENCE); break; case GCAL_RECURRENCE_MON_FRI: { - rrule->freq = ICAL_WEEKLY_RECURRENCE; - rrule->by_day[0] = ICAL_MONDAY_WEEKDAY; - rrule->by_day[1] = ICAL_TUESDAY_WEEKDAY; - rrule->by_day[2] = ICAL_WEDNESDAY_WEEKDAY; - rrule->by_day[3] = ICAL_THURSDAY_WEEKDAY; - rrule->by_day[4] = ICAL_FRIDAY_WEEKDAY; + i_cal_recurrence_set_freq (rrule, I_CAL_WEEKLY_RECURRENCE); + i_cal_recurrence_set_by_day (rrule, 0, I_CAL_MONDAY_WEEKDAY); + i_cal_recurrence_set_by_day (rrule, 1, I_CAL_TUESDAY_WEEKDAY); + i_cal_recurrence_set_by_day (rrule, 2, I_CAL_WEDNESDAY_WEEKDAY); + i_cal_recurrence_set_by_day (rrule, 3, I_CAL_THURSDAY_WEEKDAY); + i_cal_recurrence_set_by_day (rrule, 4, I_CAL_FRIDAY_WEEKDAY); break; } default: - rrule->freq = ICAL_NO_RECURRENCE; + i_cal_recurrence_set_freq (rrule, I_CAL_NO_RECURRENCE); break; } switch (recur->limit_type) { case GCAL_RECURRENCE_COUNT: - rrule->count = recur->limit.count; + i_cal_recurrence_set_count (rrule, recur->limit.count); break; case GCAL_RECURRENCE_UNTIL: { - rrule->until.second = g_date_time_get_second (recur->limit.until); - rrule->until.minute = g_date_time_get_minute (recur->limit.until); - rrule->until.hour = g_date_time_get_hour (recur->limit.until); - rrule->until.day = g_date_time_get_day_of_month (recur->limit.until); - rrule->until.month = g_date_time_get_month (recur->limit.until); - rrule->until.year = g_date_time_get_year (recur->limit.until); + ICalTime *until; + + until = i_cal_time_new_null_time (); + i_cal_time_set_date (until, + g_date_time_get_year (recur->limit.until), + g_date_time_get_month (recur->limit.until), + g_date_time_get_day_of_month (recur->limit.until)); + i_cal_time_set_time (until, + g_date_time_get_hour (recur->limit.until), + g_date_time_get_minute (recur->limit.until), + g_date_time_get_second (recur->limit.until)); + + i_cal_recurrence_set_until (rrule, until); + + g_clear_object (&until); break; } diff --git a/src/core/gcal-recurrence.h b/src/core/gcal-recurrence.h index 13a6935d..340db66a 100644 --- a/src/core/gcal-recurrence.h +++ b/src/core/gcal-recurrence.h @@ -84,7 +84,7 @@ gboolean gcal_recurrence_is_equal (GcalRecurrence GcalRecurrence* gcal_recurrence_parse_recurrence_rules (ECalComponent *comp); -struct icalrecurrencetype* gcal_recurrence_to_rrule (GcalRecurrence *recur); +ICalRecurrence* gcal_recurrence_to_rrule (GcalRecurrence *recur); G_DEFINE_AUTOPTR_CLEANUP_FUNC (GcalRecurrence, gcal_recurrence_unref) diff --git a/src/gui/gcal-edit-dialog.c b/src/gui/gcal-edit-dialog.c index 2881bd4e..4123d0fa 100644 --- a/src/gui/gcal-edit-dialog.c +++ b/src/gui/gcal-edit-dialog.c @@ -383,23 +383,11 @@ static void remove_recurrence_properties (GcalEvent *event) { ECalComponent *comp; - icalcomponent *icalcomp; - icalproperty *prop; comp = gcal_event_get_component (event); - icalcomp = e_cal_component_get_icalcomponent (comp); e_cal_component_set_recurid (comp, NULL); - - prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); - - if (prop) - { - icalcomponent_remove_property (icalcomp, prop); - icalproperty_free (prop); - } - - e_cal_component_rescan (comp); + e_cal_component_set_rrules (comp, NULL); } static void @@ -585,7 +573,7 @@ create_row_for_alarm (GcalEvent *event, gtk_label_set_label (GTK_LABEL (label), text); /* Retrieves the actions associated to the alarm */ - e_cal_component_alarm_get_action (alarm, &action); + action = e_cal_component_alarm_get_action (alarm); /* Updates the volume button to match the action */ has_sound = action == E_CAL_COMPONENT_ALARM_AUDIO; diff --git a/src/gui/gcal-event-widget.c b/src/gui/gcal-event-widget.c index 246daa62..dc830114 100644 --- a/src/gui/gcal-event-widget.c +++ b/src/gui/gcal-event-widget.c @@ -1205,7 +1205,7 @@ gcal_event_widget_sort_events (GcalEventWidget *widget1, { g_autoptr (GDateTime) dt_time1 = NULL; g_autoptr (GDateTime) dt_time2 = NULL; - icaltimetype *ical_dt; + ICalTime *itt; gint diff; diff = gcal_event_is_multiday (widget2->event) - gcal_event_is_multiday (widget1->event); @@ -1223,13 +1223,15 @@ gcal_event_widget_sort_events (GcalEventWidget *widget1, if (diff != 0) return diff; - e_cal_component_get_last_modified (gcal_event_get_component (widget1->event), &ical_dt); - if (ical_dt) - dt_time1 = gcal_date_time_from_icaltime (ical_dt); + itt = e_cal_component_get_last_modified (gcal_event_get_component (widget1->event)); + if (itt) + dt_time1 = gcal_date_time_from_icaltime (itt); + g_clear_object (&itt); - e_cal_component_get_last_modified (gcal_event_get_component (widget2->event), &ical_dt); - if (ical_dt) - dt_time2 = gcal_date_time_from_icaltime (ical_dt); + itt = e_cal_component_get_last_modified (gcal_event_get_component (widget2->event)); + if (itt) + dt_time2 = gcal_date_time_from_icaltime (itt); + g_clear_object (&itt); return dt_time1 && dt_time2 ? g_date_time_compare (dt_time2, dt_time1) : 0; } diff --git a/src/gui/gcal-event-widget.h b/src/gui/gcal-event-widget.h index 72e0a0ab..05ad16bc 100644 --- a/src/gui/gcal-event-widget.h +++ b/src/gui/gcal-event-widget.h @@ -24,8 +24,6 @@ #include -#include - G_BEGIN_DECLS #define GCAL_TYPE_EVENT_WIDGET (gcal_event_widget_get_type ()) diff --git a/src/gui/gcal-window.c b/src/gui/gcal-window.c index 1e3ef508..2b13c34e 100644 --- a/src/gui/gcal-window.c +++ b/src/gui/gcal-window.c @@ -37,7 +37,6 @@ #include #include -#include /** * SECTION:gcal-window diff --git a/src/utils/gcal-date-time-utils.c b/src/utils/gcal-date-time-utils.c index 2f9db23a..88b6725b 100644 --- a/src/utils/gcal-date-time-utils.c +++ b/src/utils/gcal-date-time-utils.c @@ -152,29 +152,32 @@ gcal_date_time_compare_date (GDateTime *dt1, * gcal_date_time_to_icaltime: * @dt: a #GDateTime * - * Converts the #GDateTime's @dt to an #icaltimetype. + * Converts the #GDateTime's @dt to an #ICalTime. * - * Returns: (transfer full): a #icaltimetype. + * Returns: (transfer full): a #ICalTime. */ -icaltimetype* +ICalTime* gcal_date_time_to_icaltime (GDateTime *dt) { - icaltimetype *idt; + ICalTime *idt; if (!dt) return NULL; - idt = g_new0 (icaltimetype, 1); + idt = i_cal_time_new_null_time (); - idt->year = g_date_time_get_year (dt); - idt->month = g_date_time_get_month (dt); - idt->day = g_date_time_get_day_of_month (dt); - idt->hour = g_date_time_get_hour (dt); - idt->minute = g_date_time_get_minute (dt); - idt->second = g_date_time_get_seconds (dt); - idt->is_date = (idt->hour == 0 && - idt->minute == 0 && - idt->second == 0); + i_cal_time_set_date (idt, + g_date_time_get_year (dt), + g_date_time_get_month (dt), + g_date_time_get_day_of_month (dt)); + i_cal_time_set_time (idt, + g_date_time_get_hour (dt), + g_date_time_get_minute (dt), + g_date_time_get_seconds (dt)); + i_cal_time_set_is_date (idt, + i_cal_time_get_hour (idt) == 0 && + i_cal_time_get_minute (idt) == 0 && + i_cal_time_get_second (idt) == 0); return idt; @@ -201,26 +204,28 @@ gcal_date_time_is_date (GDateTime *dt) /** * gcal_date_time_from_icaltime: - * @date: an #icaltimetype + * @date: an #ICalTime * * Creates a #GDateTime from @date. The timezone is preserved. * * Returns: (transfer full): a #GDateTime. */ GDateTime* -gcal_date_time_from_icaltime (const icaltimetype *date) +gcal_date_time_from_icaltime (const ICalTime *date) { g_autoptr (GTimeZone) tz = NULL; g_autoptr (GDateTime) dt = NULL; + ICalTimezone *zone; - tz = date->zone ? g_time_zone_new (icaltime_get_tzid (*date)) : g_time_zone_new_utc (); + zone = i_cal_time_get_timezone (date); + tz = (zone && i_cal_timezone_get_location (zone)) ? g_time_zone_new (i_cal_timezone_get_location (zone)) : g_time_zone_new_utc (); dt = g_date_time_new (tz, - date->year, - date->month, - date->day, - date->is_date ? 0 : date->hour, - date->is_date ? 0 : date->minute, - date->is_date ? 0 : date->second); + i_cal_time_get_year (date), + i_cal_time_get_month (date), + i_cal_time_get_day (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_hour (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_minute (date), + i_cal_time_is_date (date) ? 0 : i_cal_time_get_second (date)); return g_steal_pointer (&dt); } diff --git a/src/utils/gcal-date-time-utils.h b/src/utils/gcal-date-time-utils.h index 9ba7dbc3..369082b0 100644 --- a/src/utils/gcal-date-time-utils.h +++ b/src/utils/gcal-date-time-utils.h @@ -21,7 +21,7 @@ #pragma once #include -#include +#include G_BEGIN_DECLS @@ -45,10 +45,10 @@ GDateTime* gcal_date_time_get_end_of_week (GDateTime gint gcal_date_time_compare_date (GDateTime *dt1, GDateTime *dt2); -icaltimetype* gcal_date_time_to_icaltime (GDateTime *dt); +ICalTime* gcal_date_time_to_icaltime (GDateTime *dt); gboolean gcal_date_time_is_date (GDateTime *dt); -GDateTime* gcal_date_time_from_icaltime (const icaltimetype *date); +GDateTime* gcal_date_time_from_icaltime (const ICalTime *date); G_END_DECLS diff --git a/src/utils/gcal-utils.c b/src/utils/gcal-utils.c index ed0b5480..855ac459 100644 --- a/src/utils/gcal-utils.c +++ b/src/utils/gcal-utils.c @@ -230,7 +230,7 @@ get_desc_from_component (ECalComponent *component, GSList *l; gchar *desc = NULL; - e_cal_component_get_description_list (component, &text_list); + text_list = e_cal_component_get_descriptions (component); for (l = text_list; l != NULL; l = l->next) { @@ -242,18 +242,18 @@ get_desc_from_component (ECalComponent *component, if (desc != NULL) { - carrier = g_strconcat (desc, joint_char, text->value, NULL); + carrier = g_strconcat (desc, joint_char, e_cal_component_text_get_value (text), NULL); g_free (desc); desc = carrier; } else { - desc = g_strdup (text->value); + desc = g_strdup (e_cal_component_text_get_value (text)); } } } - e_cal_component_free_text_list (text_list); + g_slist_free_full (text_list, e_cal_component_text_free); return desc != NULL ? g_strstrip (desc) : NULL; } @@ -276,20 +276,20 @@ get_uuid_from_component (ESource *source, ECalComponentId *id; id = e_cal_component_get_id (component); - if (id->rid != NULL) + if (e_cal_component_id_get_rid (id) != NULL) { uuid = g_strdup_printf ("%s:%s:%s", e_source_get_uid (source), - id->uid, - id->rid); + e_cal_component_id_get_uid (id), + e_cal_component_id_get_rid (id)); } else { uuid = g_strdup_printf ("%s:%s", e_source_get_uid (source), - id->uid); + e_cal_component_id_get_uid (id)); } - e_cal_component_free_id (id); + e_cal_component_id_free (id); return uuid; } @@ -369,9 +369,10 @@ build_component_from_details (const gchar *summary, GDateTime *final_date) { ECalComponent *event; - ECalComponentDateTime dt; - ECalComponentText summ; - icaltimezone *zone; + ECalComponentDateTime *dt; + ECalComponentText *summ; + ICalTimezone *zone; + ICalTime *itt; gboolean all_day; event = e_cal_component_new (); @@ -389,42 +390,38 @@ build_component_from_details (const gchar *summary, */ if (all_day) { - zone = icaltimezone_get_utc_timezone (); + zone = i_cal_timezone_get_utc_timezone (); } else { - gchar *system_tz = e_cal_system_timezone_get_location (); - - zone = icaltimezone_get_builtin_timezone (system_tz); - - g_free (system_tz); + zone = e_cal_util_get_system_timezone (); } /* Start date */ - dt.value = gcal_date_time_to_icaltime (initial_date); - icaltime_set_timezone (dt.value, zone); - dt.value->is_date = all_day; - dt.tzid = icaltimezone_get_tzid (zone); - e_cal_component_set_dtstart (event, &dt); + itt = gcal_date_time_to_icaltime (initial_date); + i_cal_time_set_timezone (itt, zone); + i_cal_time_set_is_date (itt, all_day); + dt = e_cal_component_datetime_new_take (itt, zone ? g_strdup (i_cal_timezone_get_tzid (zone)) : NULL); + e_cal_component_set_dtstart (event, dt); - g_free (dt.value); + e_cal_component_datetime_free (dt); /* End date */ if (!final_date) final_date = g_date_time_add_days (initial_date, 1); - dt.value = gcal_date_time_to_icaltime (final_date); - icaltime_set_timezone (dt.value, zone); - dt.value->is_date = all_day; - dt.tzid = icaltimezone_get_tzid (zone); - e_cal_component_set_dtend (event, &dt); + itt = gcal_date_time_to_icaltime (final_date); + i_cal_time_set_timezone (itt, zone); + i_cal_time_set_is_date (itt, all_day); + dt = e_cal_component_datetime_new_take (itt, zone ? g_strdup (i_cal_timezone_get_tzid (zone)) : NULL); + e_cal_component_set_dtend (event, dt); - g_free (dt.value); + e_cal_component_datetime_free (dt); /* Summary */ - summ.altrep = NULL; - summ.value = summary; - e_cal_component_set_summary (event, &summ); + summ = e_cal_component_text_new (summary, NULL); + e_cal_component_set_summary (event, summ); + e_cal_component_text_free (summ); e_cal_component_commit_sequence (event); @@ -433,11 +430,11 @@ build_component_from_details (const gchar *summary, /** * icaltime_compare_date: - * @date1: an #icaltimetype - * @date2: an #icaltimetype + * @date1: an #ICalTime + * @date2: an #ICalTime * - * Compare date parts of #icaltimetype objects. Returns negative value, - * 0 or positive value accordingly if @date1 is before, same day of + * Compare date parts of #ICalTime objects. Returns negative value, + * 0 or positive value accordingly if @date1 is before, same day or * after date2. * * As a bonus it returns the amount of days passed between two days on the @@ -446,25 +443,25 @@ build_component_from_details (const gchar *summary, * Returns: negative, 0 or positive **/ gint -icaltime_compare_date (const icaltimetype *date1, - const icaltimetype *date2) +icaltime_compare_date (const ICalTime *date1, + const ICalTime *date2) { if (date2 == NULL) return 0; - if (date1->year < date2->year) + if (i_cal_time_get_year (date1) < i_cal_time_get_year (date2)) return -1; - else if (date1->year > date2->year) + else if (i_cal_time_get_year (date1) > i_cal_time_get_year (date2)) return 1; else - return time_day_of_year (date1->day, date1->month - 1, date1->year) - - time_day_of_year (date2->day, date2->month - 1, date2->year); + return time_day_of_year (i_cal_time_get_day (date1), i_cal_time_get_month (date1) - 1, i_cal_time_get_year (date1)) - + time_day_of_year (i_cal_time_get_day (date2), i_cal_time_get_month (date2) - 1, i_cal_time_get_year (date2)); } /** * icaltime_compare_with_current: - * @date1: an #icaltimetype - * @date2: an #icaltimetype + * @date1: an #ICalTime + * @date2: an #ICalTime * @current_time_t: the current time * * Compares @date1 and @date2 against the current time. Dates @@ -474,15 +471,24 @@ icaltime_compare_date (const icaltimetype *date1, * equal, positive otherwise */ gint -icaltime_compare_with_current (const icaltimetype *date1, - const icaltimetype *date2, - time_t *current_time_t) +icaltime_compare_with_current (const ICalTime *date1, + const ICalTime *date2, + time_t *current_time_t) { + ICalTimezone *zone1, *zone2; 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 ()); + + zone1 = i_cal_time_get_timezone (date1); + if (!zone1) + zone1 = e_cal_util_get_system_timezone (); + + zone2 = i_cal_time_get_timezone (date2); + if (!zone2) + zone2 = e_cal_util_get_system_timezone (); + + start1 = i_cal_time_as_timet_with_zone (date1, zone1); + start2 = i_cal_time_as_timet_with_zone (date2, zone2); diff1 = start1 - *current_time_t; diff2 = start2 - *current_time_t; @@ -802,26 +808,28 @@ gint get_alarm_trigger_minutes (GcalEvent *event, ECalComponentAlarm *alarm) { - ECalComponentAlarmTrigger trigger; + ECalComponentAlarmTrigger *trigger; + ICalDuration *duration; GDateTime *alarm_dt; gint diff; - e_cal_component_alarm_get_trigger (alarm, &trigger); + trigger = e_cal_component_alarm_get_trigger (alarm); /* * We only support alarms relative to the start date, and solely * ignore whetever different it may be. */ - if (trigger.type != E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START) + if (!trigger || e_cal_component_alarm_trigger_get_kind (trigger) != E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START) return -1; + duration = e_cal_component_alarm_trigger_get_duration (trigger); alarm_dt = g_date_time_add_full (gcal_event_get_date_start (event), 0, 0, - - (trigger.u.rel_duration.days + trigger.u.rel_duration.weeks * 7), - - trigger.u.rel_duration.hours, - - trigger.u.rel_duration.minutes, - - trigger.u.rel_duration.seconds); + - (i_cal_duration_get_days (duration) + i_cal_duration_get_weeks (duration) * 7), + - i_cal_duration_get_hours (duration), + - i_cal_duration_get_minutes (duration), + - i_cal_duration_get_seconds (duration)); diff = g_date_time_difference (gcal_event_get_date_start (event), alarm_dt) / G_TIME_SPAN_MINUTE; @@ -941,7 +949,7 @@ ask_recurrence_modification_type (GtkWidget *parent, client = g_object_get_data (G_OBJECT (source), "client"); - if (!e_client_check_capability (E_CLIENT (client), CAL_STATIC_CAPABILITY_NO_THISANDFUTURE)) + if (!e_client_check_capability (E_CLIENT (client), E_CAL_STATIC_CAPABILITY_NO_THISANDFUTURE)) gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Subsequent events"), GTK_RESPONSE_OK); gtk_dialog_add_button (GTK_DIALOG (dialog), _("_All events"), GTK_RESPONSE_YES); @@ -1108,7 +1116,7 @@ filter_event_list_by_uid_and_modtype (GList *widgets, component = gcal_event_get_component (event); calendar = gcal_event_get_calendar (event); id = e_cal_component_get_id (component); - id_prefix = g_strdup_printf ("%s:%s", gcal_calendar_get_id (calendar), id->uid); + id_prefix = g_strdup_printf ("%s:%s", gcal_calendar_get_id (calendar), e_cal_component_id_get_uid (id)); for (l = widgets; l != NULL; l = l->next) { @@ -1141,7 +1149,7 @@ filter_event_list_by_uid_and_modtype (GList *widgets, } - e_cal_component_free_id (id); + e_cal_component_id_free (id); } return result; diff --git a/src/utils/gcal-utils.h b/src/utils/gcal-utils.h index 272d9f7e..924fc6e8 100644 --- a/src/utils/gcal-utils.h +++ b/src/utils/gcal-utils.h @@ -26,7 +26,6 @@ #include #include #include -#include #define ALIGNED(x) (round (x) + 0.5) #define MINUTES_PER_DAY 1440 @@ -41,6 +40,7 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (ESource, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC (ECalComponent, g_object_unref) G_DEFINE_AUTOPTR_CLEANUP_FUNC (GWeatherLocation, gweather_location_unref) +G_DEFINE_AUTOPTR_CLEANUP_FUNC (ICalTime, g_object_unref) gchar* gcal_get_weekday (gint i); @@ -67,12 +67,12 @@ ECalComponent* build_component_from_details (const gchar GDateTime *initial_date, GDateTime *final_date); -gint icaltime_compare_date (const icaltimetype *date1, - const icaltimetype *date2); +gint icaltime_compare_date (const ICalTime *date1, + const ICalTime *date2); -gint icaltime_compare_with_current (const icaltimetype *date1, - const icaltimetype *date2, - time_t *current_time_t); +gint icaltime_compare_with_current (const ICalTime *date1, + const ICalTime *date2, + time_t *current_time_t); gboolean is_clock_format_24h (void); diff --git a/src/views/gcal-month-popover.c b/src/views/gcal-month-popover.c index ef3879b5..9ec74f05 100644 --- a/src/views/gcal-month-popover.c +++ b/src/views/gcal-month-popover.c @@ -295,8 +295,8 @@ reposition_popover (GcalMonthPopover *self, static void update_event_list (GcalMonthPopover *self) { - g_autofree icaltimetype *start = NULL; - g_autofree icaltimetype *end = NULL; + g_autoptr (ICalTime) start = NULL; + g_autoptr (ICalTime) end = NULL; g_autoptr (GDateTime) start_dt = NULL; g_autoptr (GDateTime) end_dt = NULL; g_autoptr (GList) events = NULL; @@ -322,6 +322,9 @@ update_event_list (GcalMonthPopover *self) events = gcal_manager_get_events (gcal_context_get_manager (self->context), start, end); + g_clear_object (&start); + g_clear_object (&end); + for (l = events; l; l = l->next) { g_autoptr (GDateTime) event_start = NULL; diff --git a/src/views/gcal-year-view.c b/src/views/gcal-year-view.c index c02bb7ba..25c432b8 100644 --- a/src/views/gcal-year-view.c +++ b/src/views/gcal-year-view.c @@ -407,8 +407,8 @@ add_event_to_day_array (GcalYearView *year_view, static void update_sidebar (GcalYearView *year_view) { - g_autofree icaltimetype *start_icaldatetime = NULL; - g_autofree icaltimetype *end_icaldatetime = NULL; + g_autoptr (ICalTime) start_icaldatetime = NULL; + g_autoptr (ICalTime) end_icaldatetime = NULL; GcalManager *manager; GtkWidget *child_widget; GList *events, *l; @@ -1981,10 +1981,10 @@ gcal_year_view_component_changed (ECalDataModelSubscriber *subscriber, id = e_cal_component_get_id (comp); - gcal_year_view_component_removed (subscriber, client, id->uid, id->rid); + gcal_year_view_component_removed (subscriber, client, e_cal_component_id_get_uid (id), e_cal_component_id_get_rid (id)); gcal_year_view_component_added (subscriber, client, comp); - g_clear_pointer (&id, e_cal_component_free_id); + g_clear_pointer (&id, e_cal_component_id_free); GCAL_EXIT; }