From 0ec0ea81217402c1d40ba968fd945b14cf390643 Mon Sep 17 00:00:00 2001 From: Georges Basile Stavracas Neto Date: Sun, 7 Feb 2016 12:52:18 -0200 Subject: [PATCH] event-widget: use GcalEvent internally This saves a lot of code, and is much saner to maintain. --- data/ui/window.ui | 2 +- src/gcal-edit-dialog.c | 15 +- src/gcal-edit-dialog.h | 5 +- src/gcal-event-widget.c | 925 ++++++++++++++----------------------- src/gcal-event-widget.h | 50 +- src/gcal-manager.c | 22 +- src/gcal-month-view.c | 119 ++--- src/gcal-subscriber-view.c | 46 +- src/gcal-utils.c | 37 +- src/gcal-utils.h | 3 + src/gcal-week-view.c | 27 +- src/gcal-window.c | 47 +- src/gcal-year-view.c | 142 +++--- 13 files changed, 649 insertions(+), 791 deletions(-) diff --git a/data/ui/window.ui b/data/ui/window.ui index 27f0bf7e..86705f8e 100644 --- a/data/ui/window.ui +++ b/data/ui/window.ui @@ -392,7 +392,7 @@ True True - + 0 diff --git a/src/gcal-edit-dialog.c b/src/gcal-edit-dialog.c index 6a9a880d..f711bec3 100644 --- a/src/gcal-edit-dialog.c +++ b/src/gcal-edit-dialog.c @@ -793,12 +793,12 @@ gcal_edit_dialog_set_event_is_new (GcalEditDialog *dialog, } void -gcal_edit_dialog_set_event_data (GcalEditDialog *dialog, - GcalEventData *data) +gcal_edit_dialog_set_event (GcalEditDialog *dialog, + GcalEvent *event) { - GdkRGBA color; GdkPixbuf *pix; + ESource *source; const gchar *const_text = NULL; gboolean all_day; @@ -810,13 +810,14 @@ gcal_edit_dialog_set_event_data (GcalEditDialog *dialog, ECalComponentDateTime dtend; all_day = FALSE; + source = gcal_event_get_source (event); dialog->setting_event = TRUE; - g_set_object (&dialog->source, data->source); + g_set_object (&dialog->source, source); g_clear_object (&dialog->component); - dialog->component = e_cal_component_clone (data->event_component); + dialog->component = e_cal_component_clone (gcal_event_get_component (event)); g_clear_pointer (&dialog->source_uid, g_free); dialog->source_uid = e_source_dup_uid (dialog->source); @@ -850,14 +851,14 @@ gcal_edit_dialog_set_event_data (GcalEditDialog *dialog, gtk_entry_set_text (GTK_ENTRY (dialog->summary_entry), e_summary.value); /* dialog titlebar's title & subtitle */ - get_color_name_from_source (data->source, &color); + get_color_name_from_source (source, &color); pix = gcal_get_pixbuf_from_color (&color, 16); gtk_image_set_from_pixbuf (GTK_IMAGE (dialog->source_image), pix); g_object_unref (pix); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (dialog->titlebar), - e_source_get_display_name (data->source)); + e_source_get_display_name (source)); /* retrieve start and end dates */ e_cal_component_get_dtstart (dialog->component, &dtstart); diff --git a/src/gcal-edit-dialog.h b/src/gcal-edit-dialog.h index fe7abf55..60d9249b 100644 --- a/src/gcal-edit-dialog.h +++ b/src/gcal-edit-dialog.h @@ -20,6 +20,7 @@ #ifndef __GCAL_EDIT_DIALOG_H__ #define __GCAL_EDIT_DIALOG_H__ +#include "gcal-event.h" #include "gcal-manager.h" #include @@ -39,8 +40,8 @@ GtkWidget* gcal_edit_dialog_new (gboolean format_2 void gcal_edit_dialog_set_event_is_new (GcalEditDialog *dialog, gboolean event_is_new); -void gcal_edit_dialog_set_event_data (GcalEditDialog *dialog, - GcalEventData *data); +void gcal_edit_dialog_set_event (GcalEditDialog *dialog, + GcalEvent *event); void gcal_edit_dialog_set_manager (GcalEditDialog *dialog, GcalManager *manager); diff --git a/src/gcal-event-widget.c b/src/gcal-event-widget.c index bce9fef3..251046f4 100644 --- a/src/gcal-event-widget.c +++ b/src/gcal-event-widget.c @@ -20,28 +20,21 @@ #include "gcal-event-widget.h" #include "gcal-utils.h" -#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11) +#define INTENSITY(c) ((c->red) * 0.30 + (c->green) * 0.59 + (c->blue) * 0.11) struct _GcalEventWidget { GtkWidget parent; /* properties */ - gchar *uuid; - gchar *summary; - GdkRGBA *color; - icaltimetype *dt_start; - icaltimetype *dt_end; /* could be NULL, meaning dt_end is the same as start_date */ - gboolean all_day; + GDateTime *dt_start; + GDateTime *dt_end; gboolean has_reminders; /* internal data */ gboolean read_only; - /* weak ESource reference */ - ESource *source; - /* ECalComponent data */ - ECalComponent *component; + GcalEvent *event; GdkWindow *event_window; gboolean button_pressed; @@ -50,12 +43,9 @@ struct _GcalEventWidget enum { PROP_0, - PROP_UUID, - PROP_SUMMARY, - PROP_COLOR, - PROP_DTSTART, - PROP_DTEND, - PROP_ALL_DAY, + PROP_DATE_END, + PROP_DATE_START, + PROP_EVENT, PROP_HAS_REMINDERS }; @@ -67,144 +57,110 @@ enum static guint signals[NUM_SIGNALS] = { 0, }; -static void gcal_event_widget_set_property (GObject *object, - guint property_id, - const GValue *value, - GParamSpec *pspec); - -static void gcal_event_widget_get_property (GObject *object, - guint property_id, - GValue *value, - GParamSpec *pspec); - -static void gcal_event_widget_finalize (GObject *object); - -static void gcal_event_widget_get_preferred_width (GtkWidget *widget, - gint *minimum, - gint *natural); - -static void gcal_event_widget_get_preferred_height (GtkWidget *widget, - gint *minimum, - gint *natural); - -static void gcal_event_widget_realize (GtkWidget *widget); - -static void gcal_event_widget_unrealize (GtkWidget *widget); - -static void gcal_event_widget_map (GtkWidget *widget); - -static void gcal_event_widget_unmap (GtkWidget *widget); - -static void gcal_event_widget_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); - -static gboolean gcal_event_widget_draw (GtkWidget *widget, - cairo_t *cr); - -static gboolean gcal_event_widget_button_press_event (GtkWidget *widget, - GdkEventButton *event); - -static gboolean gcal_event_widget_button_release_event (GtkWidget *widget, - GdkEventButton *event); - G_DEFINE_TYPE (GcalEventWidget, gcal_event_widget, GTK_TYPE_WIDGET) static void -gcal_event_widget_class_init(GcalEventWidgetClass *klass) +gcal_event_widget_update_style (GcalEventWidget *self) { - GObjectClass *object_class; - GtkWidgetClass *widget_class; + GtkStyleContext *context; + gboolean slanted_start, slanted_end; - object_class = G_OBJECT_CLASS (klass); - object_class->set_property = gcal_event_widget_set_property; - object_class->get_property = gcal_event_widget_get_property; - object_class->finalize = gcal_event_widget_finalize; + context = gtk_widget_get_style_context (GTK_WIDGET (self)); + slanted_start = FALSE; + slanted_end = FALSE; - widget_class = GTK_WIDGET_CLASS (klass); - widget_class->get_preferred_width = gcal_event_widget_get_preferred_width; - widget_class->get_preferred_height = gcal_event_widget_get_preferred_height; - widget_class->realize = gcal_event_widget_realize; - widget_class->unrealize = gcal_event_widget_unrealize; - widget_class->map = gcal_event_widget_map; - widget_class->unmap = gcal_event_widget_unmap; - widget_class->size_allocate = gcal_event_widget_size_allocate; - widget_class->draw = gcal_event_widget_draw; - widget_class->button_press_event = gcal_event_widget_button_press_event; - widget_class->button_release_event = gcal_event_widget_button_release_event; + /* Clear previous style classes */ + gtk_style_context_remove_class (context, "slanted"); + gtk_style_context_remove_class (context, "slanted-start"); + gtk_style_context_remove_class (context, "slanted-end"); - g_object_class_install_property (object_class, - PROP_UUID, - g_param_spec_string ("uuid", - "Unique uid", - "The unique-unique id composed of source_uid:event_uid", - NULL, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + /* + * If the event's dates differs from the widget's dates, + * add a slanted edge class at the widget. + */ - g_object_class_install_property (object_class, - PROP_SUMMARY, - g_param_spec_string ("summary", - "Summary", - "The event summary", - NULL, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + if (self->dt_start) + slanted_start = g_date_time_compare (gcal_event_get_date_start (self->event), self->dt_start) != 0; - g_object_class_install_property (object_class, - PROP_COLOR, - g_param_spec_boxed ("color", - "Color", - "The color to render", - GDK_TYPE_RGBA, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + if (self->dt_end) + slanted_end = g_date_time_compare (gcal_event_get_date_end (self->event), self->dt_end) != 0; - g_object_class_install_property (object_class, - PROP_DTSTART, - g_param_spec_boxed ("date-start", - "Date Start", - "The starting date of the event", - ICAL_TIME_TYPE, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + if (slanted_start && slanted_end) + gtk_style_context_add_class (context, "slanted"); + else if (slanted_start) + gtk_style_context_add_class (context, "slanted-start"); + else if (slanted_end) + gtk_style_context_add_class (context, "slanted-end"); +} - g_object_class_install_property (object_class, - PROP_DTEND, - g_param_spec_boxed ("date-end", - "Date End", - "The end date of the event", - ICAL_TIME_TYPE, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); +static void +update_color (GcalEventWidget *self) +{ + GtkStyleContext *context; + GdkRGBA *color; + GQuark color_id; + gchar *color_str; + gchar *css_class; - g_object_class_install_property (object_class, - PROP_ALL_DAY, - g_param_spec_boolean ("all-day", - "All day", - "Wheter the event is all-day or not", - FALSE, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + context = gtk_widget_get_style_context (GTK_WIDGET (self)); + color = gcal_event_get_color (self->event); - g_object_class_install_property (object_class, - PROP_HAS_REMINDERS, - g_param_spec_boolean ("has-reminders", - "Event has reminders", - "Wheter the event has reminders set or not", - FALSE, - G_PARAM_CONSTRUCT | - G_PARAM_READWRITE)); + color_str = gdk_rgba_to_string (color); + color_id = g_quark_from_string (color_str); + css_class = g_strdup_printf ("color-%d", color_id); - signals[ACTIVATE] = g_signal_new ("activate", - GCAL_TYPE_EVENT_WIDGET, - G_SIGNAL_RUN_LAST, - 0, - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, - 0); + gtk_style_context_add_class (context, css_class); - gtk_widget_class_set_css_name (widget_class, "event-widget"); + if (INTENSITY (color) > 0.5) + { + gtk_style_context_remove_class (context, "color-dark"); + gtk_style_context_add_class (context, "color-light"); + } + else + { + gtk_style_context_remove_class (context, "color-light"); + gtk_style_context_add_class (context, "color-dark"); + } + + g_free (color_str); + g_free (css_class); +} + +static void +gcal_event_widget_set_event_internal (GcalEventWidget *self, + GcalEvent *event) +{ + /* + * This function is called only once, since the property is + * set as CONSTRUCT_ONLY. Any other attempt to set an event + * will be ignored. + * + * Because of that condition, we don't really have to care about + * disconnecting functions or cleaning up the previous event. + */ + + /* The event spawns with a floating reference, and we take it's ownership */ + g_set_object (&self->event, event); + + /* + * Initially, the widget's start and end dates are the same + * of the event's ones. We may change it afterwards. + */ + gcal_event_widget_set_date_start (self, gcal_event_get_date_start (event)); + gcal_event_widget_set_date_end (self, gcal_event_get_date_end (event)); + + /* Update color */ + update_color (self); + + g_signal_connect_swapped (event, + "notify::color", + G_CALLBACK (update_color), + self); + + g_signal_connect_swapped (event, + "notify::summary", + G_CALLBACK (gtk_widget_queue_draw), + self); } static void @@ -224,71 +180,29 @@ gcal_event_widget_set_property (GObject *object, switch (property_id) { - case PROP_UUID: - g_clear_pointer (&self->uuid, g_free); - self->uuid = g_value_dup_string (value); - g_object_notify (object, "uuid"); - return; - case PROP_SUMMARY: - g_clear_pointer (&self->summary, g_free); - self->summary = g_value_dup_string (value); - g_object_notify (object, "summary"); - return; - case PROP_COLOR: - { - GtkStyleContext *context; + case PROP_DATE_END: + gcal_event_widget_set_date_end (self, g_value_get_boxed (value)); + break; - context = gtk_widget_get_style_context (GTK_WIDGET (object)); + case PROP_DATE_START: + gcal_event_widget_set_date_start (self, g_value_get_boxed (value)); + break; - g_clear_pointer (&self->color, gdk_rgba_free); - self->color = g_value_dup_boxed (value); + case PROP_EVENT: + gcal_event_widget_set_event_internal (self, g_value_get_object (value)); + break; - if (self->color == NULL) - return; - - if (INTENSITY (self->color->red, - self->color->green, - self->color->blue) > 0.5) - { - gtk_style_context_remove_class (context, "color-dark"); - gtk_style_context_add_class (context, "color-light"); - } - else - { - gtk_style_context_remove_class (context, "color-light"); - gtk_style_context_add_class (context, "color-dark"); - } - - g_object_notify (object, "color"); - return; - } - case PROP_DTSTART: - g_clear_pointer (&self->dt_start, g_free); - self->dt_start = g_value_dup_boxed (value); - g_object_notify (object, "date-start"); - return; - case PROP_DTEND: - g_clear_pointer (&self->dt_end, g_free); - self->dt_end = g_value_dup_boxed (value); - g_object_notify (object, "date-end"); - return; - case PROP_ALL_DAY: - if (self->all_day != g_value_get_boolean (value)) - { - self->all_day = g_value_get_boolean (value); - g_object_notify (object, "all-day"); - } - return; case PROP_HAS_REMINDERS: if (self->has_reminders != g_value_get_boolean (value)) { self->has_reminders = g_value_get_boolean (value); - g_object_notify (object, "all-day"); + g_object_notify (object, "has-reminders"); } - return; - } + break; - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } } static void @@ -301,30 +215,25 @@ gcal_event_widget_get_property (GObject *object, switch (property_id) { - case PROP_UUID: - g_value_set_string (value, self->uuid); - return; - case PROP_SUMMARY: - g_value_set_string (value, self->summary); - return; - case PROP_COLOR: - g_value_set_boxed (value, self->color); - return; - case PROP_DTSTART: - g_value_set_boxed (value, self->dt_start); - return; - case PROP_DTEND: + case PROP_DATE_END: g_value_set_boxed (value, self->dt_end); - return; - case PROP_ALL_DAY: - g_value_set_boolean (value, self->all_day); - return; + break; + + case PROP_DATE_START: + g_value_set_boxed (value, self->dt_start); + break; + + case PROP_EVENT: + g_value_set_object (value, self->event); + break; + case PROP_HAS_REMINDERS: g_value_set_boolean (value, self->has_reminders); - return; - } + break; - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } } static void @@ -334,14 +243,8 @@ gcal_event_widget_finalize (GObject *object) self = GCAL_EVENT_WIDGET (object); - g_clear_object (&self->component); - /* releasing properties */ - g_clear_pointer (&self->uuid, g_free); - g_clear_pointer (&self->summary, g_free); - g_clear_pointer (&self->color, gdk_rgba_free); - g_clear_pointer (&self->dt_start, g_free); - g_clear_pointer (&self->dt_end, g_free); + g_clear_object (&self->event); G_OBJECT_CLASS (gcal_event_widget_parent_class)->finalize (object); } @@ -533,7 +436,7 @@ gcal_event_widget_draw (GtkWidget *widget, /* FIXME for RTL alignment and icons positions */ gtk_style_context_get (context, state, "font", &font_desc, NULL); - layout = gtk_widget_create_pango_layout (widget, self->summary); + layout = gtk_widget_create_pango_layout (widget, gcal_event_get_summary (self->event)); pango_layout_set_font_description (layout, font_desc); pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END); pango_layout_set_width (layout, (width - (padding.left + padding.right) ) * PANGO_SCALE); @@ -649,141 +552,107 @@ gcal_event_widget_button_release_event (GtkWidget *widget, return FALSE; } -GtkWidget* -gcal_event_widget_new (gchar *uuid) + +static void +gcal_event_widget_class_init(GcalEventWidgetClass *klass) { - return g_object_new (GCAL_TYPE_EVENT_WIDGET, "uuid", uuid, NULL); + GObjectClass *object_class; + GtkWidgetClass *widget_class; + + object_class = G_OBJECT_CLASS (klass); + object_class->set_property = gcal_event_widget_set_property; + object_class->get_property = gcal_event_widget_get_property; + object_class->finalize = gcal_event_widget_finalize; + + widget_class = GTK_WIDGET_CLASS (klass); + widget_class->get_preferred_width = gcal_event_widget_get_preferred_width; + widget_class->get_preferred_height = gcal_event_widget_get_preferred_height; + widget_class->realize = gcal_event_widget_realize; + widget_class->unrealize = gcal_event_widget_unrealize; + widget_class->map = gcal_event_widget_map; + widget_class->unmap = gcal_event_widget_unmap; + widget_class->size_allocate = gcal_event_widget_size_allocate; + widget_class->draw = gcal_event_widget_draw; + widget_class->button_press_event = gcal_event_widget_button_press_event; + widget_class->button_release_event = gcal_event_widget_button_release_event; + + /** + * GcalEventWidget::date-end: + * + * The end date this widget represents. Notice that this may + * differ from the event's end date. For example, if the event + * spans more than one month and we're in Month View, the end + * date marks the last day this event is visible. + */ + g_object_class_install_property (object_class, + PROP_DATE_END, + g_param_spec_boxed ("date-end", + "End date", + "The end date of the widget", + G_TYPE_DATE_TIME, + G_PARAM_READWRITE)); + + /** + * GcalEventWidget::date-start: + * + * The start date this widget represents. Notice that this may + * differ from the event's start date. For example, if the event + * spans more than one month and we're in Month View, the start + * date marks the first day this event is visible. + */ + g_object_class_install_property (object_class, + PROP_DATE_START, + g_param_spec_boxed ("date-start", + "Start date", + "The start date of the widget", + G_TYPE_DATE_TIME, + G_PARAM_READWRITE)); + + /** + * GcalEventWidget::event: + * + * The event this widget represents. + */ + g_object_class_install_property (object_class, + PROP_EVENT, + g_param_spec_object ("event", + "Event", + "The event this widget represents", + GCAL_TYPE_EVENT, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + + /** + * GcalEventWidget::has-reminders: + * + * Whether the event has reminders or not. + */ + g_object_class_install_property (object_class, + PROP_HAS_REMINDERS, + g_param_spec_boolean ("has-reminders", + "Event has reminders", + "Wheter the event has reminders set or not", + FALSE, + G_PARAM_READWRITE)); + + signals[ACTIVATE] = g_signal_new ("activate", + GCAL_TYPE_EVENT_WIDGET, + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); + + gtk_widget_class_set_css_name (widget_class, "event-widget"); } -/** - * gcal_event_widget_new_from_data: - * @data: a #GcalEventData instance - * - * Create an event widget by passing its #ECalComponent and #ESource - * - * Returns: a #GcalEventWidget as #GtkWidget - **/ -GtkWidget* -gcal_event_widget_new_from_data (GcalEventData *data) -{ - GtkWidget *widget; - GcalEventWidget *event; - - gchar *uuid; - ECalComponentId *id; - ECalComponentText e_summary; - - GQuark color_id; - GdkRGBA color; - gchar *color_str, *custom_css_class; - - ECalComponentDateTime dt; - icaltimetype *date; - gboolean start_is_date, end_is_date; - - id = e_cal_component_get_id (data->event_component); - if (id->rid != NULL) - { - uuid = g_strdup_printf ("%s:%s:%s", - e_source_get_uid (data->source), - id->uid, - id->rid); - } - else - { - uuid = g_strdup_printf ("%s:%s", - e_source_get_uid (data->source), - id->uid); - } - widget = g_object_new (GCAL_TYPE_EVENT_WIDGET, "uuid", uuid, NULL); - e_cal_component_free_id (id); - g_free (uuid); - - event = GCAL_EVENT_WIDGET (widget); - event->component = data->event_component; - event->source = data->source; - - /* summary */ - e_cal_component_get_summary (event->component, &e_summary); - gcal_event_widget_set_summary (event, (gchar*) e_summary.value); - - /* color */ - get_color_name_from_source (event->source, &color); - gcal_event_widget_set_color (event, &color); - - color_str = gdk_rgba_to_string (&color); - color_id = g_quark_from_string (color_str); - custom_css_class = g_strdup_printf ("color-%d", color_id); - gtk_style_context_add_class (gtk_widget_get_style_context (widget), custom_css_class); - g_free (custom_css_class); - g_free (color_str); - - /* start date */ - e_cal_component_get_dtstart (event->component, &dt); - date = gcal_dup_icaltime (dt.value); - - start_is_date = date->is_date == 1; - if (!start_is_date) - { - if (dt.tzid != NULL) - dt.value->zone = icaltimezone_get_builtin_timezone_from_tzid (dt.tzid); - *date = icaltime_convert_to_zone (*(dt.value), - e_cal_util_get_system_timezone ()); - } - - gcal_event_widget_set_date (event, date); - e_cal_component_free_datetime (&dt); - g_free (date); - - /* end date */ - e_cal_component_get_dtend (event->component, &dt); - if (dt.value != NULL) - { - date = gcal_dup_icaltime (dt.value); - - end_is_date = date->is_date == 1; - if (!end_is_date) - { - if (dt.tzid != NULL) - dt.value->zone = icaltimezone_get_builtin_timezone_from_tzid (dt.tzid); - *date = icaltime_convert_to_zone (*(dt.value), - e_cal_util_get_system_timezone ()); - } - - gcal_event_widget_set_end_date (event, date); - e_cal_component_free_datetime (&dt); - g_free (date); - - /* set_all_day */ - gcal_event_widget_set_all_day (event, start_is_date && end_is_date); - } - - /* set_has_reminders */ - gcal_event_widget_set_has_reminders (event, e_cal_component_has_alarms (event->component)); - - return widget; -} GtkWidget* -gcal_event_widget_clone (GcalEventWidget *widget) +gcal_event_widget_new (GcalEvent *event) { - GtkWidget *new_widget; - GcalEventData *data; - - data = gcal_event_widget_get_data (widget); - g_object_ref (data->event_component); - - new_widget = gcal_event_widget_new_from_data (data); - g_free (data); - - gcal_event_widget_set_read_only(GCAL_EVENT_WIDGET (new_widget), gcal_event_widget_get_read_only (widget)); - return new_widget; -} - -const gchar* -gcal_event_widget_peek_uuid (GcalEventWidget *event) -{ - return event->uuid; + return g_object_new (GCAL_TYPE_EVENT_WIDGET, + "event", event, + NULL); } void @@ -801,172 +670,6 @@ gcal_event_widget_get_read_only (GcalEventWidget *event) return event->read_only; } -/** - * gcal_event_widget_set_date: - * @event: a #GcalEventWidget - * @date: a #icaltimetype object with the date - * - * Set the start-date of the event - **/ -void -gcal_event_widget_set_date (GcalEventWidget *event, - const icaltimetype *date) -{ - g_object_set (event, "date-start", date, NULL); -} - -/** - * gcal_event_widget_get_date: - * @event: a #GcalEventWidget - * - * Return the starting date of the event - * - * Returns: (transfer full): Release with g_free() - **/ -icaltimetype* -gcal_event_widget_get_date (GcalEventWidget *event) -{ - icaltimetype *dt; - - g_object_get (event, "date-start", &dt, NULL); - return dt; -} - -/** - * gcal_event_widget_peek_start_date: - * @event: - * - * Return the starting date of the event. - * - * Returns: (Transfer none): An {@link icaltimetype} instance - **/ -const icaltimetype* -gcal_event_widget_peek_start_date (GcalEventWidget *event) -{ - return event->dt_start; -} - -/** - * gcal_event_widget_set_end_date: - * @event: a #GcalEventWidget - * @date: a #icaltimetype object with the date - * - * Set the end date of the event - **/ -void -gcal_event_widget_set_end_date (GcalEventWidget *event, - const icaltimetype *date) -{ - g_object_set (event, "date-end", date, NULL); -} - -/** - * gcal_event_widget_get_end_date: - * @event: a #GcalEventWidget - * - * Return the end date of the event. If the event has no end_date - * (as Google does on 0 sec events) %NULL will be returned - * - * Returns: (transfer full): Release with g_free() - **/ -icaltimetype* -gcal_event_widget_get_end_date (GcalEventWidget *event) -{ - icaltimetype *dt; - - g_object_get (event, "date-end", &dt, NULL); - return dt; -} - -/** - * gcal_event_widget_peek_end_date: - * @event: - * - * Return the end date of the event. - * - * Returns: (Transfer none): An {@link icaltimetype} instance - **/ -const icaltimetype* -gcal_event_widget_peek_end_date (GcalEventWidget *event) -{ - return event->dt_end != NULL ? event->dt_end : event->dt_start; -} - -void -gcal_event_widget_set_summary (GcalEventWidget *event, - gchar *summary) -{ - g_return_if_fail (GCAL_IS_EVENT_WIDGET (event)); - - g_object_set (event, "summary", summary, NULL); -} - -gchar* -gcal_event_widget_get_summary (GcalEventWidget *event) -{ - return g_strdup (event->summary); -} - -void -gcal_event_widget_set_color (GcalEventWidget *event, - GdkRGBA *color) -{ - g_return_if_fail (GCAL_IS_EVENT_WIDGET (event)); - - g_object_set (event, "color", color, NULL); -} - -GdkRGBA* -gcal_event_widget_get_color (GcalEventWidget *event) -{ - GdkRGBA *color; - g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (event), NULL); - - color = NULL; - g_object_get (event, "color", color, NULL); - return color; -} - -void -gcal_event_widget_set_all_day (GcalEventWidget *event, - gboolean all_day) -{ - g_return_if_fail (GCAL_IS_EVENT_WIDGET (event)); - - g_object_set (event, "all-day", all_day, NULL); -} - -gboolean -gcal_event_widget_get_all_day (GcalEventWidget *event) -{ - gboolean all_day; - g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (event), FALSE); - - g_object_get (event, "all-day", &all_day, NULL); - return all_day; -} - -gboolean -gcal_event_widget_is_multiday (GcalEventWidget *event) -{ - gint start_day_of_year, end_day_of_year; - - if (event->dt_end == NULL) - return FALSE; - - start_day_of_year = icaltime_day_of_year (*(event->dt_start)); - end_day_of_year = icaltime_day_of_year (*(event->dt_end)); - - if (event->all_day && start_day_of_year + 1 == end_day_of_year) - return FALSE; - - if (event->all_day && start_day_of_year == icaltime_days_in_year (event->dt_start->year) && end_day_of_year == 1 && - event->dt_start->year + 1 == event->dt_end->year) - return FALSE; - - return start_day_of_year != end_day_of_year; -} - void gcal_event_widget_set_has_reminders (GcalEventWidget *event, gboolean has_reminders) @@ -979,34 +682,134 @@ gcal_event_widget_set_has_reminders (GcalEventWidget *event, gboolean gcal_event_widget_get_has_reminders (GcalEventWidget *event) { - gboolean has_reminders; g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (event), FALSE); - g_object_get (event, "has-reminders", &has_reminders, NULL); - return has_reminders; + return event->has_reminders; } /** - * gcal_event_widget_get_data: - * @event: a #GcalEventWidget instance + * gcal_event_widget_get_date_end: + * @self: a #GcalEventWidget * - * Returns a #GcalEventData with shallows members, meaning the members - * are owned but the struct should be freed. + * Retrieves the visible end date of this widget. This + * may differ from the event's end date. * - * Returns: (transfer full): a #GcalEventData - **/ -GcalEventData* -gcal_event_widget_get_data (GcalEventWidget *event) + * Returns: (transfer none): a #GDateTime + */ +GDateTime* +gcal_event_widget_get_date_end (GcalEventWidget *self) { - GcalEventData *data; + g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (self), NULL); - g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (event), NULL); + return self->dt_end ? self->dt_end : self->dt_start; +} - data = g_new0 (GcalEventData, 1); - data->source = event->source; - data->event_component = event->component; +/** + * gcal_event_widget_set_date_end: + * @self: a #GcalEventWidget + * @date_end: the end date of this widget + * + * Sets the visible end date of this widget. This + * may differ from the event's end date, but cannot + * be after it. + */ +void +gcal_event_widget_set_date_end (GcalEventWidget *self, + GDateTime *date_end) +{ + g_return_if_fail (GCAL_IS_EVENT_WIDGET (self)); - return data; + if (self->dt_end != date_end && + (!self->dt_end || !date_end || + (self->dt_end && date_end && !g_date_time_equal (self->dt_end, date_end)))) + { + /* The end date should never be after the event's end date */ + if (date_end && g_date_time_compare (date_end, gcal_event_get_date_end (self->event)) > 0) + return; + + g_clear_pointer (&self->dt_end, g_date_time_unref); + self->dt_end = g_date_time_ref (date_end); + + gcal_event_widget_update_style (self); + + g_object_notify (G_OBJECT (self), "date-end"); + } +} + +/** + * gcal_event_widget_get_date_start: + * @self: a #GcalEventWidget + * + * Retrieves the visible start date of this widget. This + * may differ from the event's start date. + * + * Returns: (transfer none): a #GDateTime + */ +GDateTime* +gcal_event_widget_get_date_start (GcalEventWidget *self) +{ + g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (self), NULL); + + return self->dt_start; +} + +/** + * gcal_event_widget_set_date_start: + * @self: a #GcalEventWidget + * @date_end: the start date of this widget + * + * Sets the visible start date of this widget. This + * may differ from the event's start date, but cannot + * be before it. + */ +void +gcal_event_widget_set_date_start (GcalEventWidget *self, + GDateTime *date_start) +{ + g_return_if_fail (GCAL_IS_EVENT_WIDGET (self)); + + if (self->dt_start != date_start && + (!self->dt_start || !date_start || + (self->dt_start && date_start && !g_date_time_equal (self->dt_start, date_start)))) + { + /* The start date should never be before the event's start date */ + if (date_start && g_date_time_compare (date_start, gcal_event_get_date_start (self->event)) < 0) + return; + + g_clear_pointer (&self->dt_start, g_date_time_unref); + self->dt_start = g_date_time_ref (date_start); + + gcal_event_widget_update_style (self); + + g_object_notify (G_OBJECT (self), "date-start"); + } +} + +/** + * gcal_event_widget_get_event: + * @self: a #GcalEventWidget + * + * Retrieves the @GcalEvent this widget represents. + * + * Returns: (transfer none): a #GcalEvent + */ +GcalEvent* +gcal_event_widget_get_event (GcalEventWidget *self) +{ + g_return_val_if_fail (GCAL_IS_EVENT_WIDGET (self), NULL); + + return self->event; +} + +GtkWidget* +gcal_event_widget_clone (GcalEventWidget *widget) +{ + GtkWidget *new_widget; + + new_widget = gcal_event_widget_new (widget->event); + gcal_event_widget_set_read_only(GCAL_EVENT_WIDGET (new_widget), gcal_event_widget_get_read_only (widget)); + + return new_widget; } /** @@ -1023,22 +826,10 @@ gboolean gcal_event_widget_equal (GcalEventWidget *widget1, GcalEventWidget *widget2) { - ECalComponentId *id1; - ECalComponentId *id2; - - gboolean same_id = FALSE; - - if (!e_source_equal (widget1->source, widget2->source)) + if (!e_source_equal (gcal_event_get_source (widget1->event), gcal_event_get_source (widget2->event))) return FALSE; - id1 = e_cal_component_get_id (widget1->component); - id2 = e_cal_component_get_id (widget2->component); - same_id = e_cal_component_id_equal (id1, id2); - - e_cal_component_free_id (id1); - e_cal_component_free_id (id2); - - return same_id; + return g_strcmp0 (gcal_event_get_uid (widget1->event), gcal_event_get_uid (widget2->event)) == 0; } /** @@ -1057,13 +848,13 @@ gcal_event_widget_compare_by_length (GcalEventWidget *widget1, time_t time_s1, time_s2; time_t time_e1, time_e2; - time_e1 = time_s1 = icaltime_as_timet (*(widget1->dt_start)); - time_e2 = time_s2 = icaltime_as_timet (*(widget2->dt_start)); + time_e1 = time_s1 = g_date_time_to_unix (widget1->dt_start); + time_e2 = time_s2 = g_date_time_to_unix (widget2->dt_start); if (widget1->dt_end != NULL) - time_e1 = icaltime_as_timet (*(widget1->dt_end)); + time_e1 = g_date_time_to_unix (widget1->dt_end); if (widget2->dt_end) - time_e2 = icaltime_as_timet (*(widget2->dt_end)); + time_e2 = g_date_time_to_unix (widget2->dt_end); return (time_e2 - time_s2) - (time_e1 - time_s1); } @@ -1072,7 +863,7 @@ gint gcal_event_widget_compare_by_start_date (GcalEventWidget *widget1, GcalEventWidget *widget2) { - return icaltime_compare (*(widget1->dt_start), *(widget2->dt_start)); + return g_date_time_compare (widget1->dt_start, widget2->dt_start); } /** @@ -1089,39 +880,39 @@ gint gcal_event_widget_compare_for_single_day (GcalEventWidget *widget1, GcalEventWidget *widget2) { - if (gcal_event_widget_is_multiday (widget1) && gcal_event_widget_is_multiday (widget2)) + if (gcal_event_is_multiday (widget1->event) && gcal_event_is_multiday (widget2->event)) { time_t time_s1, time_s2; time_t time_e1, time_e2; time_t result; - time_s1 = icaltime_as_timet (*(widget1->dt_start)); - time_s2 = icaltime_as_timet (*(widget2->dt_start)); - time_e1 = icaltime_as_timet (*(widget1->dt_end)); - time_e2 = icaltime_as_timet (*(widget2->dt_end)); + time_s1 = g_date_time_to_unix (widget1->dt_start); + time_s2 = g_date_time_to_unix (widget2->dt_start); + time_e1 = g_date_time_to_unix (widget1->dt_end); + time_e2 = g_date_time_to_unix (widget2->dt_end); result = (time_e2 - time_s2) - (time_e1 - time_s1); if (result != 0) return result; else - return icaltime_compare (*(widget1->dt_start), *(widget2->dt_start)); + return g_date_time_compare (widget1->dt_start, widget2->dt_start); } else { - if (gcal_event_widget_is_multiday (widget1)) + if (gcal_event_is_multiday (widget1->event)) return -1; - else if (gcal_event_widget_is_multiday (widget2)) + else if (gcal_event_is_multiday (widget2->event)) return 1; else { - if (widget1->all_day && widget2->all_day) + if (gcal_event_get_all_day (widget1->event) && gcal_event_get_all_day (widget2->event)) return 0; - else if (widget1->all_day) + else if (gcal_event_get_all_day (widget1->event)) return -1; - else if (widget2->all_day) + else if (gcal_event_get_all_day (widget2->event)) return 1; else - return icaltime_compare (*(widget1->dt_start), *(widget2->dt_start)); + return g_date_time_compare (widget1->dt_start, widget2->dt_start); } } } diff --git a/src/gcal-event-widget.h b/src/gcal-event-widget.h index 4feca517..d07b79fd 100644 --- a/src/gcal-event-widget.h +++ b/src/gcal-event-widget.h @@ -20,6 +20,7 @@ #ifndef __GCAL_EVENT_WIDGET_H__ #define __GCAL_EVENT_WIDGET_H__ +#include "gcal-event.h" #include "gcal-manager.h" #include @@ -32,56 +33,33 @@ G_BEGIN_DECLS G_DECLARE_FINAL_TYPE (GcalEventWidget, gcal_event_widget, GCAL, EVENT_WIDGET, GtkWidget) -GtkWidget* gcal_event_widget_new (gchar *uuid); +GtkWidget* gcal_event_widget_new (GcalEvent *event); -GtkWidget* gcal_event_widget_new_from_data (GcalEventData *data); +GcalEvent* gcal_event_widget_get_event (GcalEventWidget *self); -GtkWidget* gcal_event_widget_clone (GcalEventWidget *widget); +GDateTime* gcal_event_widget_get_date_start (GcalEventWidget *self); -const gchar* gcal_event_widget_peek_uuid (GcalEventWidget *event); +void gcal_event_widget_set_date_start (GcalEventWidget *self, + GDateTime *date_start); + +GDateTime* gcal_event_widget_get_date_end (GcalEventWidget *self); + +void gcal_event_widget_set_date_end (GcalEventWidget *self, + GDateTime *date_end); void gcal_event_widget_set_read_only (GcalEventWidget *event, gboolean read_only); gboolean gcal_event_widget_get_read_only (GcalEventWidget *event); -void gcal_event_widget_set_date (GcalEventWidget *event, - const icaltimetype *date); - -icaltimetype* gcal_event_widget_get_date (GcalEventWidget *event); - -const icaltimetype* gcal_event_widget_peek_start_date (GcalEventWidget *event); - -void gcal_event_widget_set_end_date (GcalEventWidget *event, - const icaltimetype *date); - -icaltimetype* gcal_event_widget_get_end_date (GcalEventWidget *event); - -const icaltimetype* gcal_event_widget_peek_end_date (GcalEventWidget *event); - -void gcal_event_widget_set_summary (GcalEventWidget *event, - gchar *summary); - -gchar* gcal_event_widget_get_summary (GcalEventWidget *event); - -void gcal_event_widget_set_color (GcalEventWidget *event, - GdkRGBA *color); - -GdkRGBA* gcal_event_widget_get_color (GcalEventWidget *event); - -void gcal_event_widget_set_all_day (GcalEventWidget *event, - gboolean all_day); - -gboolean gcal_event_widget_get_all_day (GcalEventWidget *event); - -gboolean gcal_event_widget_is_multiday (GcalEventWidget *event); - void gcal_event_widget_set_has_reminders (GcalEventWidget *event, gboolean has_reminders); gboolean gcal_event_widget_get_has_reminders (GcalEventWidget *event); -GcalEventData* gcal_event_widget_get_data (GcalEventWidget *event); +/* Utilities */ + +GtkWidget* gcal_event_widget_clone (GcalEventWidget *widget); gboolean gcal_event_widget_equal (GcalEventWidget *widget1, GcalEventWidget *widget2); diff --git a/src/gcal-manager.c b/src/gcal-manager.c index 30790e33..8b606251 100644 --- a/src/gcal-manager.c +++ b/src/gcal-manager.c @@ -17,6 +17,7 @@ * with this program. If not, see . */ +#include "gcal-event.h" #include "gcal-manager.h" #include "gcal-utils.h" @@ -281,6 +282,25 @@ gather_components (ECalDataModel *data_model, return TRUE; } +static gboolean +gather_events (ECalDataModel *data_model, + ECalClient *client, + const ECalComponentId *id, + ECalComponent *comp, + time_t instance_start, + time_t instance_end, + gpointer user_data) +{ + GList **result = user_data; + GcalEvent *event; + + event = gcal_event_new (e_client_get_source (E_CLIENT (client)), comp); + + *result = g_list_append (*result, event);/* FIXME: add me sorted */ + + return TRUE; +} + /** * load_source: * @manager: Manager instance @@ -1522,7 +1542,7 @@ gcal_manager_get_events (GcalManager *manager, range_start = icaltime_as_timet_with_zone (*start_date, manager->system_timezone); range_end = icaltime_as_timet_with_zone (*end_date, manager->system_timezone); - e_cal_data_model_foreach_component (manager->e_data_model, range_start, range_end, gather_components, &list); + e_cal_data_model_foreach_component (manager->e_data_model, range_start, range_end, gather_events, &list); return list; } diff --git a/src/gcal-month-view.c b/src/gcal-month-view.c index 7ec58967..1055ed84 100644 --- a/src/gcal-month-view.c +++ b/src/gcal-month-view.c @@ -475,11 +475,6 @@ rebuild_popover_for_day (GcalMonthView *view, GdkRectangle rect; gchar *label_title; - - icaltimetype date, second_date; - const icaltimetype *dt_start, *dt_end; - gint start_comparison, end_comparison; - /* placement helpers */ gdouble start_grid_y, cell_width, cell_height; @@ -504,36 +499,44 @@ rebuild_popover_for_day (GcalMonthView *view, gtk_container_foreach (GTK_CONTAINER (priv->events_list_box), (GtkCallback) gtk_widget_destroy, NULL); l = g_hash_table_lookup (ppriv->overflow_cells, GINT_TO_POINTER (priv->pressed_overflow_indicator)); + + /* Setup the start & end dates of the events as the begin & end of day */ if (l != NULL) { - date = *(priv->date); - date.day = day; + GDateTime *current_date; + GDateTime *dt_start; + GDateTime *dt_end; + GTimeZone *tz; - second_date = date; + current_date = icaltime_to_datetime (priv->date, &tz); + dt_start = g_date_time_new (tz, + g_date_time_get_year (current_date), + g_date_time_get_month (current_date), + day, + 0, 0, 0); - date.hour = 0; - date.minute = 0; - second_date.hour = 23; - second_date.minute =59; - } - for (; l != NULL; l = g_list_next (l)) - { - child_widget = gcal_event_widget_clone (GCAL_EVENT_WIDGET (l->data)); - gtk_container_add (GTK_CONTAINER (priv->events_list_box), child_widget); - _gcal_subscriber_view_setup_child (GCAL_SUBSCRIBER_VIEW (view), child_widget); + dt_end = g_date_time_new (tz, + g_date_time_get_year (current_date), + g_date_time_get_month (current_date), + day + 1, + 0, 0, 0); - dt_start = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (child_widget)); - dt_end = gcal_event_widget_peek_end_date (GCAL_EVENT_WIDGET (child_widget)); + for (; l != NULL; l = g_list_next (l)) + { + GtkWidget *cloned_event; - date.is_date = dt_start->is_date; - start_comparison = icaltime_compare (*dt_start, date); - end_comparison = icaltime_compare (second_date, *dt_end); - if (start_comparison == -1 && end_comparison == -1) - gtk_style_context_add_class (gtk_widget_get_style_context (child_widget), "slanted"); - else if (start_comparison == -1) - gtk_style_context_add_class (gtk_widget_get_style_context (child_widget), "slanted-start"); - else if (end_comparison == -1) - gtk_style_context_add_class (gtk_widget_get_style_context (child_widget), "slanted-end"); + cloned_event = gcal_event_widget_clone (l->data); + gcal_event_widget_set_date_start (GCAL_EVENT_WIDGET (cloned_event), dt_start); + gcal_event_widget_set_date_end (GCAL_EVENT_WIDGET (cloned_event), dt_end); + + gtk_container_add (GTK_CONTAINER (priv->events_list_box), cloned_event); + _gcal_subscriber_view_setup_child (GCAL_SUBSCRIBER_VIEW (view), cloned_event); + } + + g_clear_pointer (¤t_date, g_date_time_unref); + g_clear_pointer (&dt_start, g_date_time_unref); + g_clear_pointer (&dt_end, g_date_time_unref); + g_clear_pointer (&tz, g_time_zone_unref); } /* placement calculation */ @@ -605,28 +608,33 @@ update_list_box_headers (GtkListBoxRow *row, { GcalMonthViewPrivate *priv; GtkWidget *row_child, *before_child = NULL; - const icaltimetype *row_date, *before_date = NULL; + GDateTime *row_date, *before_date = NULL; + GcalEvent *row_event; priv = gcal_month_view_get_instance_private (GCAL_MONTH_VIEW (user_data)); row_child = gtk_bin_get_child (GTK_BIN (row)); - row_date = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (row_child)); + row_event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (row_child)); + row_date = gcal_event_widget_get_date_start (GCAL_EVENT_WIDGET (row_child)); if (before != NULL) { before_child = gtk_bin_get_child (GTK_BIN (before)); - before_date = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (before_child)); + before_date = gcal_event_widget_get_date_start (GCAL_EVENT_WIDGET (before_child)); } - if (!gcal_event_widget_is_multiday (GCAL_EVENT_WIDGET (row_child)) && - !gcal_event_widget_get_all_day (GCAL_EVENT_WIDGET (row_child)) && - (before_date == NULL || before_date->hour != row_date->hour)) + if (!gcal_event_is_multiday (row_event) && + !gcal_event_get_all_day (row_event) && + (before_date == NULL || g_date_time_get_hour (before_date) != g_date_time_get_hour (row_date))) { gchar *time; GtkWidget *label, *vbox; + gint hour; + + hour = g_date_time_get_hour (row_date); if (priv->use_24h_format) - time = g_strdup_printf ("%.2d:00", row_date->hour); + time = g_strdup_printf ("%.2d:00", hour); else - time = g_strdup_printf ("%.2d:00 %s", row_date->hour % 12, row_date->hour < 12 ? "AM" : "PM"); + time = g_strdup_printf ("%.2d:00 %s", hour % 12, hour < 12 ? "AM" : "PM"); label = gtk_label_new (time); gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_DIM_LABEL); @@ -1066,11 +1074,14 @@ gcal_month_view_size_allocate (GtkWidget *widget, gint first_cell, last_cell, first_row, last_row, start, end; gboolean visible, start_before = TRUE, end_after = TRUE; - const icaltimetype *date; + GDateTime *date; + GcalEvent *event; GArray *cells, *lengths; child_widget = (GtkWidget*) l->data; - uuid = gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (child_widget)); + event = gcal_event_widget_get_event (l->data); + uuid = gcal_event_get_uid (event); + if (!gtk_widget_is_visible (child_widget) && !g_hash_table_contains (ppriv->hidden_as_overflow, uuid)) continue; @@ -1078,30 +1089,30 @@ gcal_month_view_size_allocate (GtkWidget *widget, gtk_widget_get_preferred_height (child_widget, NULL, &natural_height); j = 1; - date = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (child_widget)); - if (date->month == priv->date->month) + date = gcal_event_widget_get_date_start (GCAL_EVENT_WIDGET (child_widget)); + if (g_date_time_get_month (date) == priv->date->month) { - j = date->day; + j = g_date_time_get_day_of_month (date); start_before = FALSE; } j += priv->days_delay; first_cell = 7 * ((j - 1) / 7)+ 6 * priv->k + sw * ((j - 1) % 7); j = icaltime_days_in_month (priv->date->month, priv->date->year); - date = gcal_event_widget_peek_end_date (GCAL_EVENT_WIDGET (child_widget)); - if (gcal_event_widget_get_all_day (GCAL_EVENT_WIDGET (child_widget))) + date = gcal_event_widget_get_date_end (GCAL_EVENT_WIDGET (child_widget)); + if (gcal_event_get_all_day (event)) { - if (date->month == priv->date->month) + if (g_date_time_get_month (date) == priv->date->month) { - j = date->day - 1; + j = g_date_time_get_day_of_month (date) - 1; end_after = FALSE; } } else { - if (date->month == priv->date->month) + if (g_date_time_get_month (date) == priv->date->month) { - j = date->day; + j = g_date_time_get_day_of_month (date); end_after = FALSE; } } @@ -1221,7 +1232,8 @@ gcal_month_view_size_allocate (GtkWidget *widget, { child_widget = (GtkWidget*) aux->data; - uuid = gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (child_widget)); + uuid = gcal_event_get_uid (gcal_event_widget_get_event (GCAL_EVENT_WIDGET (child_widget))); + if (!gtk_widget_is_visible (child_widget) && !g_hash_table_contains (ppriv->hidden_as_overflow, uuid)) continue; @@ -1797,15 +1809,18 @@ static gboolean gcal_month_view_is_child_multiday (GcalSubscriberView *subscriber, GcalEventWidget *child) { - return gcal_event_widget_is_multiday (child); + return gcal_event_is_multiday (gcal_event_widget_get_event (child)); } static guint gcal_month_view_get_child_cell (GcalSubscriberView *subscriber, GcalEventWidget *child) { - const icaltimetype *dt_start = gcal_event_widget_peek_start_date (child); - return dt_start->day; + GDateTime *dt; + + dt = gcal_event_widget_get_date_start (child); + + return g_date_time_get_day_of_month (dt); } static void diff --git a/src/gcal-subscriber-view.c b/src/gcal-subscriber-view.c index 937c7631..43ae97fa 100644 --- a/src/gcal-subscriber-view.c +++ b/src/gcal-subscriber-view.c @@ -21,8 +21,9 @@ #include "gcal-subscriber-view.h" #include "gcal-subscriber-view-private.h" -#include "gcal-view.h" +#include "gcal-event.h" #include "gcal-event-widget.h" +#include "gcal-view.h" enum { @@ -169,13 +170,15 @@ gcal_subscriber_view_add (GtkContainer *container, GtkWidget *widget) { GcalSubscriberViewPrivate *priv; + GcalEvent *event; const gchar *uuid; GList *l = NULL; g_return_if_fail (GCAL_IS_EVENT_WIDGET (widget)); g_return_if_fail (gtk_widget_get_parent (widget) == NULL); priv = gcal_subscriber_view_get_instance_private (GCAL_SUBSCRIBER_VIEW (container)); - uuid = gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (widget)); + event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (widget)); + uuid = gcal_event_get_uid (event); /* inserting in all children hash */ if (g_hash_table_lookup (priv->children, uuid) != NULL) @@ -215,6 +218,7 @@ gcal_subscriber_view_remove (GtkContainer *container, GtkWidget *widget) { GcalSubscriberViewPrivate *priv; + GcalEvent *event; const gchar *uuid; GList *l, *aux; @@ -222,8 +226,8 @@ gcal_subscriber_view_remove (GtkContainer *container, g_return_if_fail (gtk_widget_get_parent (widget) == GTK_WIDGET (container)); priv = gcal_subscriber_view_get_instance_private (GCAL_SUBSCRIBER_VIEW (container)); - - uuid = gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (widget)); + event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (widget)); + uuid = gcal_event_get_uid (event); l = g_hash_table_lookup (priv->children, uuid); if (l != NULL) @@ -352,20 +356,17 @@ gcal_subscriber_view_component_added (ECalDataModelSubscriber *subscriber, ECalClient *client, ECalComponent *comp) { - GtkWidget *event; - GcalEventData *data; + GtkWidget *event_widget; + GcalEvent *event; - data = g_new0 (GcalEventData, 1); - data->source = e_client_get_source (E_CLIENT (client)); - data->event_component = e_cal_component_clone (comp); + event = gcal_event_new (e_client_get_source (E_CLIENT (client)), comp); + event_widget = gcal_event_widget_new (event); + gcal_event_widget_set_read_only (GCAL_EVENT_WIDGET (event_widget), e_client_is_readonly (E_CLIENT (client))); - event = gcal_event_widget_new_from_data (data); - gcal_event_widget_set_read_only (GCAL_EVENT_WIDGET (event), e_client_is_readonly (E_CLIENT (client))); + gtk_widget_show (event_widget); + gtk_container_add (GTK_CONTAINER (subscriber), event_widget); - gtk_widget_show (event); - gtk_container_add (GTK_CONTAINER (subscriber), event); - - g_free (data); + g_clear_object (&event); } static void @@ -376,17 +377,14 @@ gcal_subscriber_view_component_modified (ECalDataModelSubscriber *subscriber, GcalSubscriberViewPrivate *priv; GList *l; GtkWidget *new_widget; - GcalEventData *data; + GcalEvent *event; priv = gcal_subscriber_view_get_instance_private (GCAL_SUBSCRIBER_VIEW (subscriber)); - data = g_new0 (GcalEventData, 1); - data->source = e_client_get_source (E_CLIENT (client)); - data->event_component = e_cal_component_clone (comp); + event = gcal_event_new (e_client_get_source (E_CLIENT (client)), comp); + new_widget = gcal_event_widget_new (event); - new_widget = gcal_event_widget_new_from_data (data); - g_free (data); + l = g_hash_table_lookup (priv->children, gcal_event_get_uid (event)); - l = g_hash_table_lookup (priv->children, gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (new_widget))); if (l != NULL) { gtk_widget_destroy (l->data); @@ -397,10 +395,12 @@ gcal_subscriber_view_component_modified (ECalDataModelSubscriber *subscriber, else { g_warning ("%s: Widget with uuid: %s not found in view: %s", - G_STRFUNC, gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (new_widget)), + G_STRFUNC, gcal_event_get_uid (event), gtk_widget_get_name (GTK_WIDGET (subscriber))); gtk_widget_destroy (new_widget); } + + g_clear_object (&event); } static void diff --git a/src/gcal-utils.c b/src/gcal-utils.c index cba10991..552de36c 100644 --- a/src/gcal-utils.c +++ b/src/gcal-utils.c @@ -63,6 +63,29 @@ month_item[12] = G_DEFINE_BOXED_TYPE (icaltimetype, icaltime, gcal_dup_icaltime, g_free) +gint +datetime_compare_date (GDateTime *dt1, + GDateTime *dt2) +{ + if (!dt1 && !dt2) + return 0; + else if (!dt1) + return -1; + else if (!dt2) + return 1; + + if (g_date_time_get_year (dt1) != g_date_time_get_year (dt2)) + return g_date_time_get_year (dt1) - g_date_time_get_year (dt2); + + if (g_date_time_get_month (dt1) != g_date_time_get_month (dt2)) + return g_date_time_get_month (dt1) - g_date_time_get_month (dt2); + + if (g_date_time_get_day_of_month (dt1) != g_date_time_get_day_of_month (dt2)) + return g_date_time_get_day_of_month (dt1) - g_date_time_get_day_of_month (dt2); + + return 0; +} + icaltimetype* datetime_to_icaltime (GDateTime *dt) { @@ -233,22 +256,18 @@ gcal_compare_event_widget_by_date (gconstpointer a, /* negative value if a < b; zero if a = b; positive value if a > b. */ GcalViewChild *a_child; GcalViewChild *b_child; - icaltimetype *a_date; - icaltimetype *b_date; + GDateTime *a_date; + GDateTime *b_date; gint comparison; a_child = (GcalViewChild*) a; b_child = (GcalViewChild*) b; - a_date = - gcal_event_widget_get_date (GCAL_EVENT_WIDGET (a_child->widget)); - b_date = - gcal_event_widget_get_date (GCAL_EVENT_WIDGET (b_child->widget)); + a_date = gcal_event_get_date_start (gcal_event_widget_get_event (GCAL_EVENT_WIDGET (a_child->widget))); + b_date = gcal_event_get_date_start (gcal_event_widget_get_event (GCAL_EVENT_WIDGET (b_child->widget))); - comparison = icaltime_compare (*a_date, *b_date); - g_free (a_date); - g_free (b_date); + comparison = g_date_time_compare (a_date, b_date); return comparison; } diff --git a/src/gcal-utils.h b/src/gcal-utils.h index 9397b052..303e1a00 100644 --- a/src/gcal-utils.h +++ b/src/gcal-utils.h @@ -52,6 +52,9 @@ const gchar* (*GcalTranslateFunc) (GtkWidget GType icaltime_get_type (void) G_GNUC_CONST; +gint datetime_compare_date (GDateTime *dt1, + GDateTime *dt2); + icaltimetype* datetime_to_icaltime (GDateTime *dt); gboolean datetime_is_date (GDateTime *dt); diff --git a/src/gcal-week-view.c b/src/gcal-week-view.c index b97891ba..8854a79b 100644 --- a/src/gcal-week-view.c +++ b/src/gcal-week-view.c @@ -1131,9 +1131,10 @@ gcal_week_view_add (GtkContainer *container, GList *l; gint day; - icaltimetype *date; GcalWeekViewChild *new_child; + GDateTime *date; + GcalEvent *event; g_return_if_fail (GCAL_IS_WEEK_VIEW (container)); g_return_if_fail (GCAL_IS_EVENT_WIDGET (widget)); @@ -1141,8 +1142,9 @@ gcal_week_view_add (GtkContainer *container, priv = gcal_week_view_get_instance_private (GCAL_WEEK_VIEW (container)); /* Check if it's already added for date */ - date = gcal_event_widget_get_date (GCAL_EVENT_WIDGET (widget)); - day = (icaltime_day_of_week (*date) - priv->first_weekday + 6) % 7; + event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (widget)); + date = gcal_event_get_date_start (event); + day = (g_date_time_get_day_of_week (date) - priv->first_weekday + 6) % 7; for (l = priv->days[day]; l != NULL; l = l->next) { @@ -1164,7 +1166,7 @@ gcal_week_view_add (GtkContainer *container, new_child->widget = widget; new_child->hidden_by_me = FALSE; - if (gcal_event_widget_get_all_day (GCAL_EVENT_WIDGET (widget))) + if (gcal_event_get_all_day (event)) { new_child->index = -1; if (gtk_widget_get_window (widget) != NULL) @@ -1173,7 +1175,7 @@ gcal_week_view_add (GtkContainer *container, } else { - new_child->index = date->hour; + new_child->index = g_date_time_get_hour (date); if (priv->grid_window != NULL) gtk_widget_set_parent_window (widget, priv->grid_window); } @@ -1185,7 +1187,6 @@ gcal_week_view_add (GtkContainer *container, "activate", G_CALLBACK (event_opened), container); - g_free (date); } static void @@ -1193,17 +1194,18 @@ gcal_week_view_remove (GtkContainer *container, GtkWidget *widget) { GcalWeekViewPrivate *priv; + GcalEvent *event; + GDateTime *date; GList *l; - icaltimetype *date; gint day; gboolean was_visible; g_return_if_fail (GCAL_IS_WEEK_VIEW (container)); g_return_if_fail (gtk_widget_get_parent (widget) == GTK_WIDGET (container)); priv = gcal_week_view_get_instance_private (GCAL_WEEK_VIEW (container)); - - date = gcal_event_widget_get_date (GCAL_EVENT_WIDGET (widget)); - day = (icaltime_day_of_week (*date) - priv->first_weekday + 6) % 7; + event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (widget)); + date = gcal_event_get_date_start (event); + day = (g_date_time_get_day_of_week (date) - priv->first_weekday + 6) % 7; for (l = priv->days[day]; l != NULL; l = l->next) { @@ -1347,10 +1349,13 @@ gcal_week_view_get_by_uuid (GcalSubscriberView *subscriber_view, for (l = priv->days[i]; l != NULL; l = l->next) { GcalWeekViewChild *child; + GcalEvent *event; const gchar* widget_uuid; child = (GcalWeekViewChild*) l->data; - widget_uuid = gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (child->widget)); + event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (child->widget)); + widget_uuid = gcal_event_get_uid (event); + if (g_strcmp0 (uuid, widget_uuid) == 0) return child->widget; } diff --git a/src/gcal-window.c b/src/gcal-window.c index 093212cf..a75e60ae 100644 --- a/src/gcal-window.c +++ b/src/gcal-window.c @@ -773,7 +773,7 @@ new_event_entry_text_changed (GObject *object, static gboolean blocked = TRUE; gint length; - length = g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (user_data)), -1); + length = g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (object)), -1); gtk_widget_set_sensitive (window->new_event_create_button, length > 0); @@ -1083,18 +1083,13 @@ create_event (gpointer user_data, window->event_creation_data->end_date); if (widget == window->new_event_details_button) { - GcalEventData *edata; + GcalEvent *event; - edata = g_new0 (GcalEventData, 1); - edata->source = source; - edata->event_component = comp; + event = gcal_event_new (source, comp); - gcal_edit_dialog_set_event_is_new (GCAL_EDIT_DIALOG (window->edit_dialog), - TRUE); - gcal_edit_dialog_set_event_data (GCAL_EDIT_DIALOG (window->edit_dialog), - edata); + gcal_edit_dialog_set_event_is_new (GCAL_EDIT_DIALOG (window->edit_dialog), TRUE); + gcal_edit_dialog_set_event (GCAL_EDIT_DIALOG (window->edit_dialog), event); g_object_unref (comp); - g_free (edata); gtk_dialog_run (GTK_DIALOG (window->edit_dialog)); } @@ -1104,7 +1099,9 @@ create_event (gpointer user_data, gcal_manager_create_event (window->manager, source, comp); } - g_object_unref (source); + g_clear_object (&source); + g_clear_object (&event); + g_clear_object (&comp); } static void @@ -1114,19 +1111,18 @@ create_event_detailed_cb (GcalView *view, gpointer user_data) { GcalWindow *window = GCAL_WINDOW (user_data); - GcalEventData *edata; + ECalComponent *comp; + GcalEvent *event; - edata = g_new0 (GcalEventData, 1); - edata->source = gcal_manager_get_default_source (window->manager); - edata->event_component = build_component_from_details ("", (icaltimetype*) start_span, (icaltimetype*) end_span); + comp = build_component_from_details ("", (icaltimetype*) start_span, (icaltimetype*) end_span); + event = gcal_event_new (gcal_manager_get_default_source (window->manager), comp); gcal_edit_dialog_set_event_is_new (GCAL_EDIT_DIALOG (window->edit_dialog), TRUE); - gcal_edit_dialog_set_event_data (GCAL_EDIT_DIALOG (window->edit_dialog), edata); - - g_object_unref (edata->event_component); - g_free (edata); + gcal_edit_dialog_set_event (GCAL_EDIT_DIALOG (window->edit_dialog), event); gtk_dialog_run (GTK_DIALOG (window->edit_dialog)); + + g_clear_object (&comp); } static void @@ -1135,16 +1131,11 @@ event_activated (GcalView *view, gpointer user_data) { GcalWindow *window = GCAL_WINDOW (user_data); - GcalEventData *data; + GcalEvent *event; - data = gcal_event_widget_get_data (event_widget); - gcal_edit_dialog_set_event_is_new ( - GCAL_EDIT_DIALOG (window->edit_dialog), - FALSE); - gcal_edit_dialog_set_event_data ( - GCAL_EDIT_DIALOG (window->edit_dialog), - data); - g_free (data); + event = gcal_event_widget_get_event (event_widget); + gcal_edit_dialog_set_event_is_new (GCAL_EDIT_DIALOG (window->edit_dialog), FALSE); + gcal_edit_dialog_set_event (GCAL_EDIT_DIALOG (window->edit_dialog), event); gtk_dialog_run (GTK_DIALOG (window->edit_dialog)); } diff --git a/src/gcal-year-view.c b/src/gcal-year-view.c index abd0ea8b..84886541 100644 --- a/src/gcal-year-view.c +++ b/src/gcal-year-view.c @@ -199,12 +199,14 @@ update_selected_dates_from_button_data (GcalYearView *year_view) year_view->start_selected_date->day = selected_data.start_day; year_view->start_selected_date->month = selected_data.start_month + 1; year_view->start_selected_date->year = year_view->date->year; + year_view->end_selected_date->is_date = TRUE; year_view->end_selected_date->day = selected_data.end_day; year_view->end_selected_date->month = selected_data.end_month + 1; year_view->end_selected_date->year = year_view->date->year; year_view->end_selected_date->hour = 23; year_view->end_selected_date->minute = 59; + year_view->end_selected_date->is_date = TRUE; *(year_view->end_selected_date) = icaltime_normalize (*(year_view->end_selected_date)); } else @@ -212,6 +214,7 @@ update_selected_dates_from_button_data (GcalYearView *year_view) *(year_view->start_selected_date) = *(year_view->current_date); year_view->start_selected_date->hour = 0; year_view->start_selected_date->minute = 0; + year_view->start_selected_date->second = 0; *(year_view->end_selected_date) = *(year_view->current_date); year_view->end_selected_date->hour = 23; @@ -254,50 +257,59 @@ update_no_events_page (GcalYearView *year_view) static void add_event_to_day_array (GcalYearView *year_view, - GcalEventData *event_data, + GcalEvent *event, GList **days_widgets_array, gint days_span) { GtkWidget *child_widget; - const icaltimetype *dt_start, *dt_end; - icaltimetype date, second_date; + GDateTime *dt_start, *dt_end; + GDateTime *date, *second_date; + GTimeZone *tz; gint i; gboolean child_widget_used = FALSE; - child_widget = gcal_event_widget_new_from_data (event_data); + child_widget = gcal_event_widget_new (event); gcal_event_widget_set_read_only (GCAL_EVENT_WIDGET (child_widget), - !gcal_manager_is_client_writable (year_view->manager, event_data->source)); + !gcal_manager_is_client_writable (year_view->manager, gcal_event_get_source (event))); - dt_start = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (child_widget)); - dt_end = gcal_event_widget_peek_end_date (GCAL_EVENT_WIDGET (child_widget)); + dt_start = gcal_event_get_date_start (event); + dt_end = gcal_event_get_date_end (event); /* normalize date on each new event */ - date = *(year_view->start_selected_date); - second_date = *(year_view->start_selected_date); - second_date.hour = 23; - second_date.minute = 59; + date = icaltime_to_datetime (year_view->start_selected_date, &tz); + second_date = g_date_time_new (tz, + g_date_time_get_year (date), + g_date_time_get_month (date), + g_date_time_get_day_of_month (date) + 1, + 0, 0, 0); + + gcal_event_widget_set_date_start (GCAL_EVENT_WIDGET (child_widget), date); + gcal_event_widget_set_date_end (GCAL_EVENT_WIDGET (child_widget), second_date); /* marking and cloning */ for (i = 0; i < days_span; i++) { - GtkWidget *cloned_child = child_widget; + GDateTime *aux; + GtkWidget *cloned_child; gint start_comparison, end_comparison; - if (i != 0) - { - icaltime_adjust (&date, 1, 0, 0, 0); - icaltime_adjust (&second_date, 1, 0, 0, 0); - } + cloned_child = child_widget; + start_comparison = datetime_compare_date (dt_start, date); - start_comparison = icaltime_compare_date (dt_start, &date); if (start_comparison <= 0) { if (child_widget_used) - cloned_child = gcal_event_widget_clone (GCAL_EVENT_WIDGET (child_widget)); + { + cloned_child = gcal_event_widget_clone (GCAL_EVENT_WIDGET (child_widget)); + gcal_event_widget_set_date_start (GCAL_EVENT_WIDGET (cloned_child), date); + gcal_event_widget_set_date_end (GCAL_EVENT_WIDGET (cloned_child), second_date); + } else - child_widget_used = TRUE; + { + child_widget_used = TRUE; + } } else { @@ -310,21 +322,20 @@ add_event_to_day_array (GcalYearView *year_view, cloned_child, (GCompareFunc) gcal_event_widget_compare_for_single_day); - end_comparison = icaltime_compare_date (&second_date, dt_end); - /* XXX: hack ensuring allday events with end_date a day after */ - if (end_comparison == -1 && second_date.year == dt_end->year && dt_end->is_date == 1) - end_comparison = 0; - - if (start_comparison < 0 && end_comparison < 0) - gtk_style_context_add_class (gtk_widget_get_style_context (cloned_child), "slanted"); - else if (start_comparison < 0) - gtk_style_context_add_class (gtk_widget_get_style_context (cloned_child), "slanted-start"); - else if (end_comparison < 0) - gtk_style_context_add_class (gtk_widget_get_style_context (cloned_child), "slanted-end"); + end_comparison = g_date_time_compare (second_date, dt_end); if (end_comparison == 0) break; } + + /* Move the compared dates to the next day */ + aux = date; + date = g_date_time_add_days (date, 1); + g_clear_pointer (&aux, g_date_time_unref); + + aux = second_date; + second_date = g_date_time_add_days (second_date, 1); + g_clear_pointer (&aux, g_date_time_unref); } } @@ -373,8 +384,8 @@ update_sidebar (GcalYearView *year_view) g_list_free (current_day); } + g_list_free_full (events, g_object_unref); g_free (days_widgets_array); - g_list_free_full (events, g_free); } static void @@ -393,20 +404,26 @@ update_sidebar_headers (GtkListBoxRow *row, { GcalYearView *year_view; GtkWidget *row_child, *before_child = NULL, *row_header = NULL; - const icaltimetype *row_date, *before_date = NULL; + GcalEvent *row_event, *before_event; + GDateTime *row_date, *before_date = NULL; icaltimetype date; gint row_shift, before_shift =-1; year_view = GCAL_YEAR_VIEW (user_data); row_child = gtk_bin_get_child (GTK_BIN (row)); + if (row_child == NULL) return; - row_date = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (row_child)); + + row_event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (row_child)); + row_date = gcal_event_get_date_start (row_event); row_shift = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row_child), "shift")); + if (before != NULL) { before_child = gtk_bin_get_child (GTK_BIN (before)); - before_date = gcal_event_widget_peek_start_date (GCAL_EVENT_WIDGET (before_child)); + before_event = gcal_event_widget_get_event (GCAL_EVENT_WIDGET (before_child)); + before_date = gcal_event_get_date_start (before_event); before_shift = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (before_child), "shift")); } @@ -432,17 +449,20 @@ update_sidebar_headers (GtkListBoxRow *row, gtk_container_add (GTK_CONTAINER (row_header), label); } - if (!gcal_event_widget_is_multiday (GCAL_EVENT_WIDGET (row_child)) && - !gcal_event_widget_get_all_day (GCAL_EVENT_WIDGET (row_child)) && - (before_date == NULL || before_date->hour != row_date->hour)) + if (!gcal_event_is_multiday (row_event) && + !gcal_event_get_all_day (row_event) && + (before_date == NULL || g_date_time_get_hour (before_date) != g_date_time_get_hour (row_date))) { gchar *time; GtkWidget *label; + gint hour; + + hour = g_date_time_get_hour (row_date); if (year_view->use_24h_format) - time = g_strdup_printf ("%.2d:00", row_date->hour); + time = g_strdup_printf ("%.2d:00", hour); else - time = g_strdup_printf ("%.2d:00 %s", row_date->hour % 12, row_date->hour < 12 ? "AM" : "PM"); + time = g_strdup_printf ("%.2d:00 %s", hour % 12, hour < 12 ? "AM" : "PM"); label = gtk_label_new (time); gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_DIM_LABEL); @@ -752,7 +772,7 @@ draw_month_grid (GcalYearView *year_view, box_side * (row + 1) + y + box_padding_top + layout_height + 2.0, VISUAL_CLUES_SIDE, VISUAL_CLUES_SIDE); gtk_style_context_restore (context); - g_list_free_full (events, g_free); + g_list_free_full (events, g_object_unref); } g_free (nr_day); @@ -1174,8 +1194,14 @@ gcal_year_view_get_children_by_uuid (GcalView *view, children = gtk_container_get_children (GTK_CONTAINER (year_view->events_sidebar)); for (l = children; l != NULL; l = g_list_next (l)) { - GcalEventWidget *child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); - if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_widget_peek_uuid (child_widget)) == 0) + GcalEventWidget *child_widget; + GcalEvent *event; + + child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); + event = gcal_event_widget_get_event (child_widget); + + + if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_get_uid (event)) == 0) result = g_list_append (result, child_widget); } g_list_free (children); @@ -1190,7 +1216,7 @@ gcal_year_view_component_added (ECalDataModelSubscriber *subscriber, { GcalYearView *year_view = GCAL_YEAR_VIEW (subscriber); - GcalEventData *data; + GcalEvent *event; GList **days_widgets_array; GList *l; gint i, days_span; @@ -1203,9 +1229,7 @@ gcal_year_view_component_added (ECalDataModelSubscriber *subscriber, days_span = icaltime_day_of_year(*(year_view->end_selected_date)) - icaltime_day_of_year(*(year_view->start_selected_date)) + 1; days_widgets_array = g_new0 (GList*, days_span); - data = g_new0 (GcalEventData, 1); - data->source = e_client_get_source (E_CLIENT (client)); - data->event_component = e_cal_component_clone (comp); + event = gcal_event_new (e_client_get_source (E_CLIENT (client)), comp); /* check if event belongs to range */ zone = gcal_manager_get_system_timezone (year_view->manager); @@ -1228,11 +1252,10 @@ gcal_year_view_component_added (ECalDataModelSubscriber *subscriber, (event_start >= range_start && event_start <= range_end) || (event_end >= range_start && event_end <= range_end))) { - g_object_unref (data->event_component); goto out; } - add_event_to_day_array (year_view, data, days_widgets_array, days_span); + add_event_to_day_array (year_view, event, days_widgets_array, days_span); gtk_stack_set_visible_child_name (GTK_STACK (year_view->navigator_stack), "events-list"); for (i = 0; i < days_span; i++) @@ -1251,7 +1274,7 @@ gcal_year_view_component_added (ECalDataModelSubscriber *subscriber, } out: - g_free (data); + g_clear_object (&event); g_free (days_widgets_array); } @@ -1268,8 +1291,13 @@ gcal_year_view_component_changed (ECalDataModelSubscriber *subscriber, children = gtk_container_get_children (GTK_CONTAINER (year_view->events_sidebar)); for (l = children; l != NULL; l = g_list_next (l)) { - GcalEventWidget *child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); - if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_widget_peek_uuid (child_widget)) == 0) + GcalEventWidget *child_widget; + GcalEvent *event; + + child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); + event = gcal_event_widget_get_event (child_widget); + + if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_get_uid (event)) == 0) gtk_widget_destroy (GTK_WIDGET (l->data)); } g_list_free (children); @@ -1299,8 +1327,14 @@ gcal_year_view_component_removed (ECalDataModelSubscriber *subscriber, children = gtk_container_get_children (GTK_CONTAINER (year_view->events_sidebar)); for (l = children; l != NULL; l = g_list_next (l)) { - GcalEventWidget *child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); - if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_widget_peek_uuid (child_widget)) == 0) + GcalEventWidget *child_widget; + GcalEvent *event; + + child_widget = GCAL_EVENT_WIDGET (gtk_bin_get_child (GTK_BIN (l->data))); + event = gcal_event_widget_get_event (child_widget); + + + if (child_widget != NULL && g_strcmp0 (uuid, gcal_event_get_uid (event)) == 0) { if (g_list_length (children) == 1) update_sidebar_needed = TRUE;