Port to libecal-2.0

Fixes https://gitlab.gnome.org/GNOME/gnome-calendar/merge_requests/70

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.

contrib/evolution/e-cal-data-model.c

@@ -17,92 +17,106 @@
  */
 
 #include <glib.h>
-/*#include <glib/gi18n-lib.h>*/
+/* #include <glib/gi18n-lib.h> */
 
 #include "e-cal-data-model.h"
 
-#define LOCK_PROPS() g_rec_mutex_lock (&data_model->priv->props_lock)
+void
-#define UNLOCK_PROPS() g_rec_mutex_unlock (&data_model->priv->props_lock)
-
-static void
 cal_comp_get_instance_times (ECalClient *client,
-			     icalcomponent *icalcomp,
+			     ICalComponent *icomp,
-			     const icaltimezone *default_zone,
+			     const ICalTimezone *default_zone,
-			     time_t *instance_start,
+			     ICalTime **out_instance_start,
-			     gboolean *start_is_date,
+			     ICalTime **out_instance_end,
-			     time_t *instance_end,
-			     gboolean *end_is_date,
 			     GCancellable *cancellable)
 {
-	struct icaltimetype start_time, end_time;
+	ICalTime *start_time, *end_time;
-	const icaltimezone *zone = default_zone;
+	const ICalTimezone *zone = default_zone;
 
 	g_return_if_fail (E_IS_CAL_CLIENT (client));
-	g_return_if_fail (icalcomp != NULL);
+	g_return_if_fail (icomp != NULL);
-	g_return_if_fail (instance_start != NULL);
+	g_return_if_fail (out_instance_start != NULL);
-	g_return_if_fail (instance_end != NULL);
+	g_return_if_fail (out_instance_end != NULL);
 
-	start_time = icalcomponent_get_dtstart (icalcomp);
+	start_time = i_cal_component_get_dtstart (icomp);
-	end_time = icalcomponent_get_dtend (icalcomp);
+	end_time = i_cal_component_get_dtend (icomp);
-	if (icaltime_is_null_time (end_time))
-	  end_time = start_time;
 
-	if (start_time.zone) {
+	/* Some event can have missing DTEND, then use the start_time for them */
-		zone = start_time.zone;
+	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;
+		ICalParameter *param = NULL;
-		icalproperty *prop = icalcomponent_get_first_property (icalcomp, ICAL_DTSTART_PROPERTY);
+		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);
+				tzid = i_cal_parameter_get_tzid (param);
-				if (tzid)
+				if (tzid && !e_cal_client_get_timezone_sync (client, tzid, &st_zone, cancellable, NULL))
-					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);
+	*out_instance_start = i_cal_time_clone (start_time);
-	if (start_is_date)
+	i_cal_time_set_timezone (*out_instance_start, zone);
-		*start_is_date = start_time.is_date;
 
-	if (end_time.zone) {
+	if (i_cal_time_get_timezone (end_time)) {
-		zone = end_time.zone;
+		zone = i_cal_time_get_timezone (end_time);
 	} else {
-		icalparameter *param = NULL;
+		ICalParameter *param = NULL;
-		icalproperty *prop = icalcomponent_get_first_property (icalcomp, ICAL_DTSTART_PROPERTY);
+		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);
+				tzid = i_cal_parameter_get_tzid (param);
-				if (tzid)
+				if (tzid && !e_cal_client_get_timezone_sync (client, tzid, &end_zone, cancellable, NULL))
-					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);
+	*out_instance_end = i_cal_time_clone (end_time);
-	if (end_is_date)
+	i_cal_time_set_timezone (*out_instance_end, zone);
-		*end_is_date = end_time.is_date;
+
+	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;
+	ICalComponent *icomp1, *icomp2;
-	struct icaltimetype tt1, tt2;
+	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) ||
+	    i_cal_component_get_sequence (icomp1) != i_cal_component_get_sequence (icomp2) ||
-	    g_strcmp0 (icalcomponent_get_uid (icomp1), icalcomponent_get_uid (icomp2)) != 0)
+	    g_strcmp0 (i_cal_component_get_uid (icomp1), i_cal_component_get_uid (icomp2)) != 0)
 		return FALSE;
 
-	tt1 = icalcomponent_get_recurrenceid (icomp1);
+	tt1 = i_cal_component_get_recurrenceid (icomp1);
-	tt2 = icalcomponent_get_recurrenceid (icomp2);
+	tt2 = i_cal_component_get_recurrenceid (icomp2);
-	if ((icaltime_is_valid_time (tt1) ? 1 : 0) != (icaltime_is_valid_time (tt2) ? 1 : 0) ||
+	if (((!tt1 || i_cal_time_is_valid_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_valid_time (tt2)) ? 1 : 0) ||
-	    (icaltime_is_null_time (tt1) ? 1 : 0) != (icaltime_is_null_time (tt2) ? 1 : 0) ||
+	    ((!tt1 || i_cal_time_is_null_time (tt1)) ? 1 : 0) != ((!tt2 || i_cal_time_is_null_time (tt2)) ? 1 : 0) ||
-	    icaltime_compare (tt1, tt2) != 0)
+	    i_cal_time_compare (tt1, tt2) != 0) {
+		g_clear_object (&tt1);
+		g_clear_object (&tt2);
 		return FALSE;
+	}
 
-	tt1 = icalcomponent_get_dtstamp (icomp1);
+	g_clear_object (&tt1);
-	tt2 = icalcomponent_get_dtstamp (icomp2);
+	g_clear_object (&tt2);
-	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) ||
+	tt1 = i_cal_component_get_dtstamp (icomp1);
-	    icaltime_compare (tt1, tt2) != 0)
+	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_str1 = i_cal_component_as_ical_string (icomp1);
-	as_str2 = icalcomponent_as_ical_string_r (icomp2);
+	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,
+		e_cal_component_id_hash, e_cal_component_id_equal,
-		(GDestroyNotify) e_cal_component_free_id, component_data_free);
+		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 ())
+		if (data_model->priv->zone && data_model->priv->zone != i_cal_timezone_get_utc_timezone ())
-			default_tzloc = icaltimezone_get_location (data_model->priv->zone);
+			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_id_free (old_id);
-		e_cal_component_free_id (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,
+cal_data_model_instance_generated (ICalComponent *icomp,
-				   time_t instance_start,
+				   ICalTime *instance_start,
-				   time_t instance_end,
+				   ICalTime *instance_end,
-				   gpointer data)
+				   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),
+	if (gid->skip_cancelled) {
-		gid->zone, &instance_start, NULL, &instance_end, NULL, NULL);
+		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 =
+	if (!client) {
-	  g_hash_table_lookup (data_model->priv->views, 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 (!e_cal_component_id_get_rid (id)) {
-					if (!g_hash_table_contains (gathered_uids, id->uid)) {
+					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 &&
+	if (!(instance_start <= subs_data->range_end &&
-	    instance_end > subs_data->range_start))
+	    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 &&
+	if (!(instance_start <= subs_data->range_end &&
-	    instance_end > subs_data->range_start))
+	    instance_end >= subs_data->range_start))
-		e_cal_data_model_subscriber_component_removed (subs_data->subscriber, client, id->uid, id->rid);
+		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_start < in_range_end && comp_data->instance_end > in_range_start) ||
-			     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_start < in_range_end && comp_data->instance_end > in_range_start) ||
-				     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;

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);

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')

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),
+      offset = i_cal_timezone_get_utc_offset (zone, itt, NULL);
-                                            comp->value, 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);
+  itt = gcal_date_time_to_icaltime (dt);
-  comp_dt->value = gcal_date_time_to_icaltime (dt);
-  comp_dt->value->is_date = self->all_day;
 
   if (self->all_day)
     {
-      comp_dt->value->zone = icaltimezone_get_utc_timezone ();
+      i_cal_time_set_timezone (itt, i_cal_timezone_get_utc_timezone ());
-      comp_dt->tzid = g_strdup ("UTC");
+      tzid = g_strdup ("UTC");
     }
   else
     {
-      comp_dt->value->zone = e_cal_util_get_system_timezone ();
+      ICalTimezone *zone;
-      comp_dt->tzid = g_strdup (icaltimezone_get_tzid ((icaltimezone *) comp_dt->value->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,
+                                   e_cal_component_id_get_uid (id),
-                                   id->rid);
+                                   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 *start;
-      ECalComponentDateTime end;
+      ECalComponentDateTime *end;
-      icaltimetype date;
+      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);
+          e_cal_component_datetime_free (start);
-          *start.value = icaltime_today ();
+          start = e_cal_component_datetime_new_take (i_cal_time_new_today (), NULL);
         }
 
       GCAL_TRACE_MSG ("Retrieving start timezone");
 
-      date = icaltime_normalize (*start.value);
+      date = i_cal_time_normalize (e_cal_component_datetime_get_value (start));
-      zone_start = get_timezone_from_ical (&start);
+      zone_start = get_timezone_from_ical (start);
       date_start = g_date_time_new (zone_start,
-                                    date.year, date.month, date.day,
+                                    i_cal_time_get_year (date),
-                                    date.is_date ? 0 : date.hour,
+                                    i_cal_time_get_month (date),
-                                    date.is_date ? 0 : date.minute,
+                                    i_cal_time_get_day (date),
-                                    date.is_date ? 0 : date.second);
+                                    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 */
+      g_clear_object (&date);
-      e_cal_component_get_dtend (component, &end);
 
-      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);
+          date = i_cal_time_normalize (e_cal_component_datetime_get_value (end));
-          zone_end = get_timezone_from_ical (&end);
+          zone_end = get_timezone_from_ical (end);
           date_end = g_date_time_new (zone_end,
-                                      date.year, date.month, date.day,
+                                      i_cal_time_get_year (date),
-                                      date.is_date ? 0 : date.hour,
+                                      i_cal_time_get_month (date),
-                                      date.is_date ? 0 : date.minute,
+                                      i_cal_time_get_day (date),
-                                      date.is_date ? 0 : date.second);
+                                      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);
+      e_cal_component_datetime_free (component_dt);
-      g_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);
+      e_cal_component_datetime_free (component_dt);
-      g_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;
+      if (description)
-      text_component.altrep = NULL;
+        {
+          ECalComponentText* text_component;
+          GSList list;
 
-      list.data = &text_component;
+          text_component = e_cal_component_text_new (description, NULL);
-      list.next = 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 = e_cal_component_alarm_trigger_new_relative (E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START, duration);
-  trigger.u.rel_duration.is_neg = TRUE;
-  trigger.u.rel_duration.minutes = type;
 
-  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 self->location;
-
-  return location ? 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 self->summary;
-
-  return summary.value ? summary.value : "";
 }
 
 /**
@@ -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 = e_cal_component_text_new (summary ? summary : "", NULL);
-      text_component.altrep = 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;
+  ICalComponent *icalcomp;
-  icalproperty *prop;
+  ICalProperty *prop;
-  struct icalrecurrencetype *rrule;
+  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);
+      prop = i_cal_property_new_rrule (rrule);
-      icalcomponent_add_property (icalcomp, prop);
+      i_cal_component_add_property (icalcomp, prop);
     }
 
-  /* Rescan the component for the changes to be detected and registered */
+  g_clear_object (&rrule);
-  e_cal_component_rescan (comp);
+  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;
+  ICalComponent *icalcomp;
-  icalproperty *property;
+  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;
+  ICalComponent *icalcomp;
-  icalproperty *property;
+  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);
+  for (property = i_cal_component_get_first_property (icalcomp, I_CAL_X_PROPERTY);
-       property;
+       property && (!has_original_start_tz || !has_original_end_tz);
-       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))
     {
-      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));
+      property = i_cal_property_new_x (g_time_zone_get_identifier (tz));
-      icalproperty_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-START");
+      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));
+      property = i_cal_property_new_x (g_time_zone_get_identifier (tz));
-      icalproperty_set_x_name (property, "X-GNOME-CALENDAR-ORIGINAL-TZ-END");
+      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;

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,
+                                   e_cal_component_id_get_uid (id),
-                                   id->rid,
+                                   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,
+gcal_manager_get_events (GcalManager *self,
-                         icaltimetype *start_date,
+                         ICalTime    *start_date,
-                         icaltimetype *end_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_start = i_cal_time_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_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,

src/core/gcal-manager.h

@@ -23,7 +23,7 @@
 #include "gcal-calendar.h"
 #include "gcal-event.h"
 
-#include <libical/icaltime.h>
+#include <libecal/libecal.h>
 
 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,
+                                                                  ICalTime           *range_start,
-                                                                  icaltimetype       *range_end);
+                                                                  ICalTime           *range_end);
 
 /* GNOME Shell-related functions */
 GcalEvent*           gcal_manager_get_event_from_shell_search    (GcalManager        *self,

src/core/gcal-recurrence.c

@@ -160,9 +160,9 @@ GcalRecurrence*
 gcal_recurrence_parse_recurrence_rules (ECalComponent *comp)
 {
   GcalRecurrence *recur;
-  icalproperty *prop;
+  ICalProperty *prop;
-  icalcomponent *icalcomp;
+  ICalComponent *icalcomp;
-  struct icalrecurrencetype rrule;
+  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 &&
+          if (i_cal_recurrence_get_by_day (rrule, 0) == I_CAL_MONDAY_WEEKDAY &&
-              rrule.by_day[1] == ICAL_TUESDAY_WEEKDAY &&
+              i_cal_recurrence_get_by_day (rrule, 1) == I_CAL_TUESDAY_WEEKDAY &&
-              rrule.by_day[2] == ICAL_WEDNESDAY_WEEKDAY &&
+              i_cal_recurrence_get_by_day (rrule, 2) == I_CAL_WEDNESDAY_WEEKDAY &&
-              rrule.by_day[3] == ICAL_THURSDAY_WEEKDAY &&
+              i_cal_recurrence_get_by_day (rrule, 3) == I_CAL_THURSDAY_WEEKDAY &&
-              rrule.by_day[4] == ICAL_FRIDAY_WEEKDAY &&
+              i_cal_recurrence_get_by_day (rrule, 4) == I_CAL_FRIDAY_WEEKDAY &&
-              rrule.by_day[5] != ICAL_SATURDAY_WEEKDAY &&
+              i_cal_recurrence_get_by_day (rrule, 5) != I_CAL_SATURDAY_WEEKDAY &&
-              rrule.by_day[6] != ICAL_SUNDAY_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;
+      recur->limit.count = i_cal_recurrence_get_count (rrule);
-    }
-  else if (rrule.until.year != 0)
-    {
-      recur->limit_type = GCAL_RECURRENCE_UNTIL;
-      recur->limit.until = gcal_date_time_from_icaltime (&rrule.until);
     }
   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);
+  rrule = i_cal_recurrence_new ();
-  icalrecurrencetype_clear (rrule);
 
   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;
+        i_cal_recurrence_set_freq (rrule, I_CAL_WEEKLY_RECURRENCE);
-        rrule->by_day[0] = ICAL_MONDAY_WEEKDAY;
+        i_cal_recurrence_set_by_day (rrule, 0, I_CAL_MONDAY_WEEKDAY);
-        rrule->by_day[1] = ICAL_TUESDAY_WEEKDAY;
+        i_cal_recurrence_set_by_day (rrule, 1, I_CAL_TUESDAY_WEEKDAY);
-        rrule->by_day[2] = ICAL_WEDNESDAY_WEEKDAY;
+        i_cal_recurrence_set_by_day (rrule, 2, I_CAL_WEDNESDAY_WEEKDAY);
-        rrule->by_day[3] = ICAL_THURSDAY_WEEKDAY;
+        i_cal_recurrence_set_by_day (rrule, 3, I_CAL_THURSDAY_WEEKDAY);
-        rrule->by_day[4] = ICAL_FRIDAY_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);
+        ICalTime *until;
-        rrule->until.minute = g_date_time_get_minute (recur->limit.until);
+
-        rrule->until.hour = g_date_time_get_hour (recur->limit.until);
+        until = i_cal_time_new_null_time ();
-        rrule->until.day = g_date_time_get_day_of_month (recur->limit.until);
+        i_cal_time_set_date (until,
-        rrule->until.month = g_date_time_get_month (recur->limit.until);
+                             g_date_time_get_year (recur->limit.until),
-        rrule->until.year = 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;
       }
 

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)
 

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);
-
+  e_cal_component_set_rrules (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);
 }
 
 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;

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);
+  itt = e_cal_component_get_last_modified (gcal_event_get_component (widget1->event));
-  if (ical_dt)
+  if (itt)
-    dt_time1 = gcal_date_time_from_icaltime (ical_dt);
+    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);
+  itt = e_cal_component_get_last_modified (gcal_event_get_component (widget2->event));
-  if (ical_dt)
+  if (itt)
-    dt_time2 = gcal_date_time_from_icaltime (ical_dt);
+    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;
 }

src/gui/gcal-event-widget.h

@@ -24,8 +24,6 @@
 
 #include <gtk/gtk.h>
 
-#include <libical/icaltime.h>
-
 G_BEGIN_DECLS
 
 #define GCAL_TYPE_EVENT_WIDGET                    (gcal_event_widget_get_type ())

src/gui/gcal-window.c

@@ -37,7 +37,6 @@
 
 #include <glib/gi18n.h>
 #include <libecal/libecal.h>
-#include <libical/icaltime.h>
 
 /**
  * SECTION:gcal-window

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);
+  i_cal_time_set_date (idt,
-  idt->month = g_date_time_get_month (dt);
+                       g_date_time_get_year (dt),
-  idt->day = g_date_time_get_day_of_month (dt);
+                       g_date_time_get_month (dt),
-  idt->hour = g_date_time_get_hour (dt);
+                       g_date_time_get_day_of_month (dt));
-  idt->minute = g_date_time_get_minute (dt);
+  i_cal_time_set_time (idt,
-  idt->second = g_date_time_get_seconds (dt);
+                       g_date_time_get_hour (dt),
-  idt->is_date = (idt->hour == 0 &&
+                       g_date_time_get_minute (dt),
-                  idt->minute == 0 &&
+                       g_date_time_get_seconds (dt));
-                  idt->second == 0);
+  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,
+                        i_cal_time_get_year (date),
-                        date->month,
+                        i_cal_time_get_month (date),
-                        date->day,
+                        i_cal_time_get_day (date),
-                        date->is_date ? 0 : date->hour,
+                        i_cal_time_is_date (date) ? 0 : i_cal_time_get_hour (date),
-                        date->is_date ? 0 : date->minute,
+                        i_cal_time_is_date (date) ? 0 : i_cal_time_get_minute (date),
-                        date->is_date ? 0 : date->second);
+                        i_cal_time_is_date (date) ? 0 : i_cal_time_get_second (date));
 
   return g_steal_pointer (&dt);
 }

src/utils/gcal-date-time-utils.h

@@ -21,7 +21,7 @@
 #pragma once
 
 #include <glib.h>
-#include <libical/icaltime.h>
+#include <libecal/libecal.h>
 
 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

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,
+                              e_cal_component_id_get_uid (id),
-                              id->rid);
+                              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;
+  ECalComponentDateTime *dt;
-  ECalComponentText summ;
+  ECalComponentText *summ;
-  icaltimezone *zone;
+  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 = e_cal_util_get_system_timezone ();
-
-      zone = icaltimezone_get_builtin_timezone (system_tz);
-
-      g_free (system_tz);
     }
 
   /* Start date */
-  dt.value = gcal_date_time_to_icaltime (initial_date);
+  itt = gcal_date_time_to_icaltime (initial_date);
-  icaltime_set_timezone (dt.value, zone);
+  i_cal_time_set_timezone (itt, zone);
-  dt.value->is_date = all_day;
+  i_cal_time_set_is_date (itt, all_day);
-  dt.tzid = icaltimezone_get_tzid (zone);
+  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);
+  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);
+  itt = gcal_date_time_to_icaltime (final_date);
-  icaltime_set_timezone (dt.value, zone);
+  i_cal_time_set_timezone (itt, zone);
-  dt.value->is_date = all_day;
+  i_cal_time_set_is_date (itt, all_day);
-  dt.tzid = icaltimezone_get_tzid (zone);
+  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);
+  e_cal_component_set_dtend (event, dt);
 
-  g_free (dt.value);
+  e_cal_component_datetime_free (dt);
 
   /* Summary */
-  summ.altrep = NULL;
+  summ = e_cal_component_text_new (summary, NULL);
-  summ.value = summary;
+  e_cal_component_set_summary (event, summ);
-  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
+ * @date1: an #ICalTime
- * @date2: an #icaltimetype
+ * @date2: an #ICalTime
  *
- * Compare date parts of #icaltimetype objects. Returns negative value,
+ * Compare date parts of #ICalTime objects. Returns negative value,
- * 0 or positive value accordingly if @date1 is before, same day of
+ * 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,
+icaltime_compare_date (const ICalTime *date1,
-                       const icaltimetype *date2)
+                       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) -
+    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 (date2->day, date2->month - 1, date2->year);
+           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
+ * @date1: an #ICalTime
- * @date2: an #icaltimetype
+ * @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,
+icaltime_compare_with_current (const ICalTime *date1,
-                               const icaltimetype *date2,
+                               const ICalTime *date2,
-                               time_t             *current_time_t)
+                               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),
+                                   - (i_cal_duration_get_days (duration) + i_cal_duration_get_weeks (duration) * 7),
-                                   - trigger.u.rel_duration.hours,
+                                   - i_cal_duration_get_hours (duration),
-                                   - trigger.u.rel_duration.minutes,
+                                   - i_cal_duration_get_minutes (duration),
-                                   - trigger.u.rel_duration.seconds);
+                                   - 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;

src/utils/gcal-utils.h

@@ -26,7 +26,6 @@
 #include <gtk/gtk.h>
 #include <libecal/libecal.h>
 #include <libgweather/gweather.h>
-#include <libical/icaltime.h>
 
 #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,
+gint                 icaltime_compare_date                       (const ICalTime *date1,
-                                                                  const icaltimetype *date2);
+                                                                  const ICalTime *date2);
 
-gint                 icaltime_compare_with_current               (const icaltimetype *date1,
+gint                 icaltime_compare_with_current               (const ICalTime *date1,
-                                                                  const icaltimetype *date2,
+                                                                  const ICalTime *date2,
-                                                                  time_t             *current_time_t);
+                                                                  time_t         *current_time_t);
 
 gboolean             is_clock_format_24h                         (void);
 

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_autoptr (ICalTime) start = NULL;
-  g_autofree icaltimetype *end = 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;

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_autoptr (ICalTime) start_icaldatetime = NULL;
-  g_autofree icaltimetype *end_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;
 }