Federated_Computer/federated-calendar
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Port to libecal-2.0

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