static void
calendar_appointment_generate_occurrences (CalendarAppointment *appointment,
icalcomponent *ical,
ECalClient *cal,
time_t start,
time_t end,
icaltimezone *default_zone)
{
ECalComponent *ecal;
g_assert (appointment->occurrences == NULL);
ecal = e_cal_component_new ();
e_cal_component_set_icalcomponent (ecal,
icalcomponent_new_clone (ical));
e_cal_recur_generate_instances (ecal,
start,
end,
calendar_appointment_collect_occurrence,
&appointment->occurrences,
(ECalRecurResolveTimezoneFn) resolve_timezone_id,
cal,
default_zone);
g_object_unref (ecal);
appointment->occurrences = g_slist_reverse (appointment->occurrences);
}
static void
action_calendar_taskpad_print_cb (GtkAction *action,
ECalShellView *cal_shell_view)
{
ECalShellContent *cal_shell_content;
ECalModelComponent *comp_data;
ETaskTable *task_table;
ECalComponent *comp;
ECalModel *model;
icalcomponent *clone;
GSList *list;
cal_shell_content = cal_shell_view->priv->cal_shell_content;
task_table = e_cal_shell_content_get_task_table (cal_shell_content);
model = e_task_table_get_model (task_table);
list = e_task_table_get_selected (task_table);
g_return_if_fail (list != NULL);
comp_data = list->data;
g_slist_free (list);
/* XXX We only print the first selected task. */
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
print_comp (
comp, comp_data->client,
e_cal_model_get_timezone (model),
e_cal_model_get_use_24_hour_format (model),
GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG);
g_object_unref (comp);
}
ScalixAppointment *
scalix_appointment_new (const char *calobj)
{
ScalixAppointment *comp;
icalcomponent *icalcomp = NULL;
ECalComponent *ecomp;
if (calobj != NULL) {
icalcomp = icalparser_parse_string (calobj);
if (icalcomp == NULL) {
return NULL;
}
}
comp = g_object_new (SCALIX_TYPE_APPOINTMENT, NULL);
ecomp = E_CAL_COMPONENT (comp);
if (icalcomp != NULL) {
e_cal_component_set_icalcomponent (ecomp, icalcomp);
}
return comp;
}
static void
local_record_from_uid (EMemoLocalRecord *local,
const char *uid,
EMemoConduitContext *ctxt)
{
ECalComponent *comp;
icalcomponent *icalcomp;
GError *error = NULL;
g_assert(local!=NULL);
LOG(g_message("local_record_from_uid\n"));
if (e_cal_get_object (ctxt->client, uid, NULL, &icalcomp, &error)) {
comp = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (comp, icalcomp)) {
g_object_unref (comp);
icalcomponent_free (icalcomp);
return;
}
local_record_from_comp (local, comp, ctxt);
g_object_unref (comp);
} else if (error->code == E_CALENDAR_STATUS_OBJECT_NOT_FOUND) {
comp = e_cal_component_new ();
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL);
e_cal_component_set_uid (comp, uid);
local_record_from_comp (local, comp, ctxt);
g_object_unref (comp);
} else {
INFO ("Object did not exist");
}
g_clear_error (&error);
}
void
e_task_shell_view_open_task (ETaskShellView *task_shell_view,
ECalModelComponent *comp_data)
{
EShell *shell;
EShellView *shell_view;
EShellWindow *shell_window;
ESourceRegistry *registry;
CompEditor *editor;
CompEditorFlags flags = 0;
ECalComponent *comp;
icalcomponent *clone;
icalproperty *prop;
const gchar *uid;
g_return_if_fail (E_IS_TASK_SHELL_VIEW (task_shell_view));
g_return_if_fail (E_IS_CAL_MODEL_COMPONENT (comp_data));
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell = e_shell_window_get_shell (shell_window);
registry = e_shell_get_registry (shell);
uid = icalcomponent_get_uid (comp_data->icalcomp);
editor = comp_editor_find_instance (uid);
if (editor != NULL)
goto exit;
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
prop = icalcomponent_get_first_property (
comp_data->icalcomp, ICAL_ATTENDEE_PROPERTY);
if (prop != NULL)
flags |= COMP_EDITOR_IS_ASSIGNED;
if (itip_organizer_is_user (registry, comp, comp_data->client))
flags |= COMP_EDITOR_USER_ORG;
if (!e_cal_component_has_attendees (comp))
flags |= COMP_EDITOR_USER_ORG;
editor = task_editor_new (comp_data->client, shell, flags);
comp_editor_edit_comp (editor, comp);
g_object_unref (comp);
if (flags & COMP_EDITOR_IS_ASSIGNED)
task_editor_show_assignment (TASK_EDITOR (editor));
exit:
gtk_window_present (GTK_WINDOW (editor));
}
static gboolean
deserialize (ScalixObject * object, const char *string)
{
ScalixAppointmentPrivate *priv;
icalcomponent *icomp, *subcomp;
icalcomponent_kind kind;
icaltimezone *zone;
priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object));
icomp = icalparser_parse_string (string);
if (icalcomponent_isa (icomp) != ICAL_VCALENDAR_COMPONENT) {
g_warning ("No VCALENAR while deserializing! (%s)\n", string);
icalcomponent_free (icomp);
return FALSE;
}
/* Grab the timezone if any */
subcomp = icalcomponent_get_first_component (icomp,
ICAL_VTIMEZONE_COMPONENT);
if (subcomp != NULL) {
zone = icaltimezone_new ();
icalcomponent_remove_component (icomp, subcomp);
if (icaltimezone_set_component (zone, subcomp))
priv->timezone = zone;
}
kind = ICAL_VEVENT_COMPONENT;
/* Grab the main VEVENT */
subcomp = icalcomponent_get_first_component (icomp, kind);
if (subcomp == NULL) {
icalcomponent_free (icomp);
return FALSE;
}
icalcomponent_remove_component (icomp, subcomp);
e_cal_component_set_icalcomponent (E_CAL_COMPONENT (object), subcomp);
e_cal_component_commit_sequence (E_CAL_COMPONENT (object));
priv->exceptions = NULL;
while ((subcomp = icalcomponent_get_next_component (icomp, kind))) {
icalcomponent_remove_component (icomp, subcomp);
priv->exceptions = g_slist_prepend (priv->exceptions, subcomp);
}
icalcomponent_free (icomp);
return TRUE;
}
/**
* jana_ecal_task_new:
*
* Creates a new #JanaEcalTask.
*
* Returns: A new #JanaEcalTask, cast as a #JanaTask.
*/
JanaTask *
jana_ecal_task_new ()
{
ECalComponent *comp = e_cal_component_new ();
JanaTask *task;
e_cal_component_set_icalcomponent (comp,
icalcomponent_new (ICAL_VTODO_COMPONENT));
task = JANA_TASK (g_object_new (JANA_ECAL_TYPE_TASK,
"ecalcomp", comp, NULL));
return task;
}
static gboolean
set_ical_from_mime_part (CamelMimePart * part, ScalixObject * object)
{
CamelDataWrapper *content;
CamelStream *stream;
GByteArray *data;
icalcomponent *icomp = NULL;
icalcomponent *subcomp = NULL;
ScalixAppointmentPrivate *priv;
priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object));
content = camel_medium_get_content_object (CAMEL_MEDIUM (part));
data = g_byte_array_new ();
stream = camel_stream_mem_new_with_byte_array (data);
camel_data_wrapper_decode_to_stream (content, stream);
if (data == NULL || data->data == NULL) {
g_print ("Found corrupt ical data\n");
return FALSE;
}
icomp = icalparser_parse_string ((const char *) data->data);
if (icalcomponent_isa (icomp) != ICAL_VCALENDAR_COMPONENT) {
icalcomponent_free (icomp);
return FALSE;
}
/* Grab the timezone if any */
subcomp = icalcomponent_get_first_component (icomp,
ICAL_VTIMEZONE_COMPONENT);
if (subcomp != NULL) {
icaltimezone *zone;
zone = icaltimezone_new ();
icaltimezone_set_component (zone, subcomp);
priv->timezone = zone;
}
/* Grab the main VEVENT */
subcomp = icalcomponent_get_first_component (icomp, ICAL_VEVENT_COMPONENT);
e_cal_component_set_icalcomponent (E_CAL_COMPONENT (object), subcomp);
return TRUE;
}
static gboolean
scalix_appointment_from_string (ScalixObject * object, const char *string)
{
icalcomponent *icomp, *subcomp;
icomp = icalparser_parse_string (string);
if (icalcomponent_isa (icomp) == ICAL_VCALENDAR_COMPONENT) {
subcomp = icalcomponent_get_first_component (icomp,
ICAL_VEVENT_COMPONENT);
icalcomponent_remove_component (icomp, subcomp);
icalcomponent_free (icomp);
icomp = subcomp;
}
e_cal_component_set_icalcomponent (E_CAL_COMPONENT (object), icomp);
return TRUE;
}
ECalComponent *
evo_cal_source_get_object(ECal *ecal, const char *uid, const char *rid)
{
ECalComponent *comp = NULL;
icalcomponent *icalcomp = NULL;
GError *error = NULL;
if (e_cal_get_object (ecal, uid, rid, &icalcomp, &error)) {
comp = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (comp, icalcomp)) {
g_object_unref (comp);
icalcomponent_free (icalcomp);
}
} else {
g_warning("Could not find object (uid: %s): %s\n", uid, error ? error->message : "None");
g_clear_error (&error);
}
return comp;
}
static void
action_task_forward_cb (GtkAction *action,
ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShell *shell;
EShellView *shell_view;
EShellWindow *shell_window;
ESourceRegistry *registry;
ECalModelComponent *comp_data;
ETaskTable *task_table;
ECalComponent *comp;
icalcomponent *clone;
GSList *list;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell = e_shell_window_get_shell (shell_window);
registry = e_shell_get_registry (shell);
task_shell_content = task_shell_view->priv->task_shell_content;
task_table = e_task_shell_content_get_task_table (task_shell_content);
list = e_task_table_get_selected (task_table);
g_return_if_fail (list != NULL);
comp_data = list->data;
g_slist_free (list);
/* XXX We only forward the first selected task. */
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
itip_send_comp (
registry, E_CAL_COMPONENT_METHOD_PUBLISH, comp,
comp_data->client, NULL, NULL, NULL, TRUE, FALSE);
g_object_unref (comp);
}
/**
* e_cal_backend_sexp_match_object:
* @sexp: An #ESExp object.
* @object: An iCalendar string.
* @backend: A backend.
*
* Match an iCalendar expression against the expression.
*
* Returns: TRUE if the object matches the expression, FALSE if not.
*/
gboolean
e_cal_backend_sexp_match_object (ECalBackendSExp *sexp,
const gchar *object,
ECalBackend *backend)
{
ECalComponent *comp;
icalcomponent *icalcomp;
gboolean retval;
icalcomp = icalcomponent_new_from_string ((gchar *) object);
if (!icalcomp)
return FALSE;
comp = e_cal_component_new ();
e_cal_component_set_icalcomponent (comp, icalcomp);
retval = e_cal_backend_sexp_match_comp (sexp, comp, backend);
g_object_unref (comp);
return retval;
}
static void
print_icomp (icalcomponent *icalcomp)
{
ECalComponent *ecomp;
g_return_if_fail (icalcomp != NULL);
ecomp = e_cal_component_new ();
icalcomp = icalcomponent_new_clone (icalcomp);
if (!e_cal_component_set_icalcomponent (ecomp, icalcomp)) {
icalcomponent_free (icalcomp);
g_object_unref (ecomp);
g_printerr ("%s: Failed to assing icalcomp to ECalComponent\n", G_STRFUNC);
g_print ("\n");
return;
}
print_ecomp (ecomp);
g_object_unref (ecomp);
}
static void
dates_new (DatesData *d, icalcomponent *comp, gboolean select)
{
GError *error = NULL;
char *uid = NULL;
if (!d->dcal) {
/* TODO: Prompt to create a new calendar? */
g_warning ("No calendars loaded");
return;
}
if (e_cal_create_object (d->dcal, comp, (char **)&uid, &error)) {
if (!select) return;
d->event_type = NEW_EVENT;
/* Bring up details dialog ASAP */
if (d->comp) g_object_unref (d->comp);
d->comp = e_cal_component_new ();
e_cal_component_set_icalcomponent (d->comp, comp);
dates_fill_details_dialog (d->view, d);
dates_platform_details_dlg (d, TRUE);
/* Disable calendar combo-box */
gtk_widget_set_sensitive (d->details_calendar_combobox, FALSE);
/* Select new event */
d->waiting = PENDING_CREATE;
d->uri_uid = g_strconcat (e_cal_get_uri (d->dcal), uid, NULL);
g_idle_add (dates_select_event_idle_cb, d);
} else {
g_warning ("Failed to create calendar object: %s",
error->message);
icalcomponent_free (comp);
g_error_free (error);
}
}
/** Sync changes from the server to the cache.
*
* @param cb 3E calendar backend.
*
* @return TRUE on success.
*
* @todo Handle UID/RID.
* @todo Better server error handling.
* @todo Conflict resolution.
*/
gboolean e_cal_backend_3e_sync_server_to_cache(ECalBackend3e *cb)
{
GError *local_err = NULL;
gboolean update_sync = TRUE;
icalcomponent *ical;
icalcomponent *icomp;
char filter[128];
struct tm tm;
time_t stamp = MAX(e_cal_backend_3e_get_sync_timestamp(cb) - 60 * 60 * 24, 0); /*XXX: always add 1 day padding to prevent timezone problems */
/* prepare query filter string */
gmtime_r(&stamp, &tm);
strftime(filter, sizeof(filter), "modified_since('%F %T')", &tm);
ical = get_server_objects(cb, filter);
if (ical == NULL)
{
return FALSE;
}
for (icomp = icalcomponent_get_first_component(ical, ICAL_ANY_COMPONENT);
icomp;
icomp = icalcomponent_get_next_component(ical, ICAL_ANY_COMPONENT))
{
icalcomponent_kind kind = icalcomponent_isa(icomp);
icalcomponent_set_cache_state(icomp, E_CAL_COMPONENT_CACHE_STATE_NONE);
if (kind == ICAL_VEVENT_COMPONENT)
{
ECalComponent *comp;
const char *uid = icalcomponent_get_uid(icomp);
gboolean server_deleted = icalcomponent_3e_status_is_deleted(icomp);
ECalComponentCacheState comp_state = E_CAL_COMPONENT_CACHE_STATE_NONE;
g_static_rw_lock_reader_lock(&cb->priv->cache_lock);
comp = e_cal_backend_cache_get_component(cb->priv->cache, uid, NULL);
g_static_rw_lock_reader_unlock(&cb->priv->cache_lock);
if (comp)
{
comp_state = e_cal_component_get_cache_state(comp);
}
if (server_deleted)
{
/* deleted by the server */
if (comp && e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_CREATED &&
e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_MODIFIED)
{
char *object = e_cal_component_get_as_string(comp);
ECalComponentId *id = e_cal_component_get_id(comp);
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_remove_component(cb->priv->cache, uid, NULL);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_removed(E_CAL_BACKEND(cb), id, object, NULL);
e_cal_component_free_id(id);
g_free(object);
}
}
else
{
char *old_object = NULL;
char *object;
ECalComponent *new_comp = e_cal_component_new();
e_cal_component_set_icalcomponent(new_comp, icalcomponent_new_clone(icomp));
e_cal_component_set_cache_state(new_comp, E_CAL_COMPONENT_CACHE_STATE_NONE);
e_cal_backend_3e_convert_attachment_uris_to_local(cb, new_comp);
if (comp)
{
old_object = e_cal_component_get_as_string(comp);
}
object = e_cal_component_get_as_string(new_comp);
if (old_object == NULL)
{
if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err))
{
/* not in cache yet */
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_component(cb->priv->cache, new_comp);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_created(E_CAL_BACKEND(cb), object);
}
else
{
e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err);
g_clear_error(&local_err);
update_sync = FALSE;
}
}
else if (strcmp(old_object, object))
{
/* what is in cache and what is on server differs */
if (comp_state != E_CAL_COMPONENT_CACHE_STATE_NONE)
{
/* modified in cache, don't do anything */
}
else
{
if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err))
{
/* sync with server */
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_component(cb->priv->cache, new_comp);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_modified(E_CAL_BACKEND(cb), old_object, object);
}
else
{
e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err);
g_clear_error(&local_err);
update_sync = FALSE;
}
}
}
g_free(old_object);
g_free(object);
g_object_unref(new_comp);
}
if (comp)
{
g_object_unref(comp);
}
}
else if (kind == ICAL_VTIMEZONE_COMPONENT)
{
const char *tzid = icalcomponent_get_tzid(icomp);
/* import non-existing timezones from the server */
if (!e_cal_backend_cache_get_timezone(cb->priv->cache, tzid))
{
icaltimezone *zone = icaltimezone_new();
icalcomponent *zone_comp = icalcomponent_new_clone(icomp);
if (icaltimezone_set_component(zone, zone_comp))
{
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_timezone(cb->priv->cache, zone);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
}
else
{
icalcomponent_free(zone_comp);
}
icaltimezone_free(zone, 1);
}
}
else
{
g_warning("Unsupported component kind (%d) found on the 3e server.", kind);
}
}
if (update_sync)
{
e_cal_backend_3e_set_sync_timestamp(cb, time(NULL));
}
icalcomponent_free(ical);
return TRUE;
}
static GtkWidget *
ical_get_preview (icalcomponent *icalcomp)
{
GtkWidget *preview;
GtkTreeView *tree_view;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter iter;
GHashTable *timezones;
icalcomponent *subcomp;
icaltimezone *users_zone;
if (!icalcomp || !is_icalcomp_usable (icalcomp))
return NULL;
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, E_TYPE_CAL_COMPONENT);
timezones = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, free_zone_cb);
users_zone = get_users_timezone ();
/* get timezones first */
for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_VTIMEZONE_COMPONENT);
subcomp;
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_VTIMEZONE_COMPONENT)) {
icaltimezone *zone = icaltimezone_new ();
if (!icaltimezone_set_component (zone, icalcomponent_new_clone (subcomp)) || !icaltimezone_get_tzid (zone)) {
icaltimezone_free (zone, 1);
} else {
g_hash_table_insert (timezones, (gchar *) icaltimezone_get_tzid (zone), zone);
}
}
/* then each component */
for (subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
subcomp;
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_ANY_COMPONENT)) {
icalcomponent_kind kind = icalcomponent_isa (subcomp);
if (kind == ICAL_VEVENT_COMPONENT ||
kind == ICAL_VTODO_COMPONENT ||
kind == ICAL_VJOURNAL_COMPONENT) {
ECalComponent *comp = e_cal_component_new ();
ECalComponentText summary = { 0 };
ECalComponentDateTime dt = { 0 };
gchar *formatted_dt;
if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp))) {
g_object_unref (comp);
continue;
}
e_cal_component_get_summary (comp, &summary);
e_cal_component_get_dtstart (comp, &dt);
formatted_dt = format_dt (&dt, timezones, users_zone);
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
0, kind == ICAL_VEVENT_COMPONENT ? (e_cal_component_has_attendees (comp) ? C_("iCalImp", "Meeting") : C_("iCalImp", "Event")) :
kind == ICAL_VTODO_COMPONENT ? C_("iCalImp", "Task") :
kind == ICAL_VJOURNAL_COMPONENT ? C_("iCalImp", "Memo") : "??? Other ???",
1, formatted_dt ? formatted_dt : "",
2, summary.value && *summary.value ? summary.value : summary.altrep && *summary.altrep ? summary.altrep : "",
3, comp,
-1);
g_free (formatted_dt);
e_cal_component_free_datetime (&dt);
g_object_unref (comp);
}
}
if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) {
g_object_unref (store);
g_hash_table_destroy (timezones);
return NULL;
}
preview = e_web_view_preview_new ();
gtk_widget_show (preview);
g_object_set_data_full (G_OBJECT (preview), "iCalImp-timezones", timezones, (GDestroyNotify) g_hash_table_destroy);
g_object_set_data (G_OBJECT (preview), "iCalImp-userszone", users_zone);
tree_view = e_web_view_preview_get_tree_view (E_WEB_VIEW_PREVIEW (preview));
g_return_val_if_fail (tree_view != NULL, NULL);
gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (store));
g_object_unref (store);
/* Translators: Column header for a component type; it can be Event, Task or Memo */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Type"),
gtk_cell_renderer_text_new (), "text", 0, NULL);
/* Translators: Column header for a component start date/time */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Start"),
gtk_cell_renderer_text_new (), "text", 1, NULL);
/* Translators: Column header for a component summary */
gtk_tree_view_insert_column_with_attributes (
tree_view, -1, C_("iCalImp", "Summary"),
gtk_cell_renderer_text_new (), "text", 2, NULL);
if (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL) > 1)
e_web_view_preview_show_tree_view (E_WEB_VIEW_PREVIEW (preview));
selection = gtk_tree_view_get_selection (tree_view);
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (
selection, "changed",
G_CALLBACK (preview_selection_changed_cb), preview);
preview_selection_changed_cb (selection, E_WEB_VIEW_PREVIEW (preview));
return preview;
}
static gboolean
cal_backend_http_load (ECalBackendHttp *backend,
const gchar *uri,
gchar **out_certificate_pem,
GTlsCertificateFlags *out_certificate_errors,
GCancellable *cancellable,
GError **error)
{
ECalBackendHttpPrivate *priv = backend->priv;
ETimezoneCache *timezone_cache;
SoupMessage *soup_message;
SoupSession *soup_session;
icalcomponent *icalcomp, *subcomp;
icalcomponent_kind kind;
const gchar *newuri;
SoupURI *uri_parsed;
GHashTable *old_cache;
GSList *comps_in_cache;
ESource *source;
guint status_code;
gulong cancel_id = 0;
struct {
SoupSession *soup_session;
SoupMessage *soup_message;
} cancel_data;
timezone_cache = E_TIMEZONE_CACHE (backend);
soup_session = backend->priv->soup_session;
soup_message = cal_backend_http_new_message (backend, uri);
if (soup_message == NULL) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Malformed URI: %s"), uri);
return FALSE;
}
if (G_IS_CANCELLABLE (cancellable)) {
cancel_data.soup_session = soup_session;
cancel_data.soup_message = soup_message;
cancel_id = g_cancellable_connect (
cancellable,
G_CALLBACK (cal_backend_http_cancelled),
&cancel_data, (GDestroyNotify) NULL);
}
source = e_backend_get_source (E_BACKEND (backend));
e_soup_ssl_trust_connect (soup_message, source);
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTING);
status_code = soup_session_send_message (soup_session, soup_message);
if (G_IS_CANCELLABLE (cancellable))
g_cancellable_disconnect (cancellable, cancel_id);
if (status_code == SOUP_STATUS_NOT_MODIFIED) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
/* attempts with ETag can result in 304 status code */
g_object_unref (soup_message);
priv->opened = TRUE;
return TRUE;
}
/* Handle redirection ourselves */
if (SOUP_STATUS_IS_REDIRECTION (status_code)) {
gboolean success;
newuri = soup_message_headers_get_list (
soup_message->response_headers, "Location");
d (g_message ("Redirected from %s to %s\n", async_context->uri, newuri));
if (newuri != NULL) {
gchar *redirected_uri;
if (newuri[0]=='/') {
g_warning ("Hey! Relative URI returned! Working around...\n");
uri_parsed = soup_uri_new (uri);
soup_uri_set_path (uri_parsed, newuri);
soup_uri_set_query (uri_parsed, NULL);
/* g_free (newuri); */
newuri = soup_uri_to_string (uri_parsed, FALSE);
g_message ("Translated URI: %s\n", newuri);
soup_uri_free (uri_parsed);
}
redirected_uri =
webcal_to_http_method (newuri, FALSE);
success = cal_backend_http_load (
backend, redirected_uri, out_certificate_pem, out_certificate_errors, cancellable, error);
g_free (redirected_uri);
} else {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_BAD_REQUEST,
_("Redirected to Invalid URI"));
success = FALSE;
}
if (success) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
} else {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_DISCONNECTED);
}
g_object_unref (soup_message);
return success;
}
/* check status code */
if (!SOUP_STATUS_IS_SUCCESSFUL (status_code)) {
/* because evolution knows only G_IO_ERROR_CANCELLED */
if (status_code == SOUP_STATUS_CANCELLED)
g_set_error (
error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
"%s", soup_message->reason_phrase);
else
g_set_error (
error, SOUP_HTTP_ERROR, status_code,
"%s", soup_message->reason_phrase);
if (status_code == SOUP_STATUS_SSL_FAILED) {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_SSL_FAILED);
cal_backend_http_extract_ssl_failed_data (soup_message, out_certificate_pem, out_certificate_errors);
} else {
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_DISCONNECTED);
}
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
e_source_set_connection_status (source, E_SOURCE_CONNECTION_STATUS_CONNECTED);
if (priv->store) {
const gchar *etag;
etag = soup_message_headers_get_one (
soup_message->response_headers, "ETag");
if (etag != NULL && *etag == '\0')
etag = NULL;
e_cal_backend_store_put_key_value (priv->store, "ETag", etag);
}
/* get the calendar from the response */
icalcomp = icalparser_parse_string (soup_message->response_body->data);
if (!icalcomp) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Bad file format."));
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
if (icalcomponent_isa (icalcomp) != ICAL_VCALENDAR_COMPONENT) {
g_set_error (
error, SOUP_HTTP_ERROR,
SOUP_STATUS_MALFORMED,
_("Not a calendar."));
icalcomponent_free (icalcomp);
g_object_unref (soup_message);
empty_cache (backend);
return FALSE;
}
g_object_unref (soup_message);
soup_message = NULL;
/* Update cache */
old_cache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
comps_in_cache = e_cal_backend_store_get_components (priv->store);
while (comps_in_cache != NULL) {
const gchar *uid;
ECalComponent *comp = comps_in_cache->data;
e_cal_component_get_uid (comp, &uid);
g_hash_table_insert (old_cache, g_strdup (uid), e_cal_component_get_as_string (comp));
comps_in_cache = g_slist_remove (comps_in_cache, comps_in_cache->data);
g_object_unref (comp);
}
kind = e_cal_backend_get_kind (E_CAL_BACKEND (backend));
subcomp = icalcomponent_get_first_component (icalcomp, ICAL_ANY_COMPONENT);
e_cal_backend_store_freeze_changes (priv->store);
while (subcomp) {
ECalComponent *comp;
icalcomponent_kind subcomp_kind;
icalproperty *prop = NULL;
subcomp_kind = icalcomponent_isa (subcomp);
prop = icalcomponent_get_first_property (subcomp, ICAL_UID_PROPERTY);
if (!prop && subcomp_kind == kind) {
gchar *new_uid = e_cal_component_gen_uid ();
icalcomponent_set_uid (subcomp, new_uid);
g_free (new_uid);
}
if (subcomp_kind == kind) {
comp = e_cal_component_new ();
if (e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (subcomp))) {
const gchar *uid;
gpointer orig_key, orig_value;
e_cal_component_get_uid (comp, &uid);
if (!put_component_to_store (backend, comp)) {
g_hash_table_remove (old_cache, uid);
} else if (g_hash_table_lookup_extended (old_cache, uid, &orig_key, &orig_value)) {
ECalComponent *orig_comp = e_cal_component_new_from_string (orig_value);
e_cal_backend_notify_component_modified (E_CAL_BACKEND (backend), orig_comp, comp);
g_hash_table_remove (old_cache, uid);
if (orig_comp)
g_object_unref (orig_comp);
} else {
e_cal_backend_notify_component_created (E_CAL_BACKEND (backend), comp);
}
}
g_object_unref (comp);
} else if (subcomp_kind == ICAL_VTIMEZONE_COMPONENT) {
icaltimezone *zone;
zone = icaltimezone_new ();
icaltimezone_set_component (zone, icalcomponent_new_clone (subcomp));
e_timezone_cache_add_timezone (timezone_cache, zone);
icaltimezone_free (zone, 1);
}
subcomp = icalcomponent_get_next_component (icalcomp, ICAL_ANY_COMPONENT);
}
e_cal_backend_store_thaw_changes (priv->store);
/* notify the removals */
g_hash_table_foreach_remove (old_cache, (GHRFunc) notify_and_remove_from_cache, backend);
g_hash_table_destroy (old_cache);
/* free memory */
icalcomponent_free (icalcomp);
priv->opened = TRUE;
return TRUE;
}
static const gchar *
test_object_creation (ECal *client,
gchar **uid)
{
ECalComponent *comp, *comp_retrieved;
icalcomponent *icalcomp, *icalcomp_retrieved;
struct icaltimetype tt;
ECalComponentText text;
ECalComponentDateTime dt;
ECalComponentTransparency transp;
gboolean compare;
GError *error = NULL;
comp = e_cal_component_new ();
/* set fields */
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
text.value = "Creation of new test event";
text.altrep = NULL;
e_cal_component_set_summary (comp, &text);
tt = icaltime_from_string ("20040109T090000Z");
dt.value = &tt;
dt.tzid ="UTC";
e_cal_component_set_dtstart (comp, &dt);
tt = icaltime_from_string ("20040109T103000");
dt.value = &tt;
dt.tzid ="UTC";
e_cal_component_set_dtend (comp, &dt);
e_cal_component_set_transparency (comp, E_CAL_COMPONENT_TRANSP_OPAQUE);
e_cal_component_commit_sequence (comp);
icalcomp = e_cal_component_get_icalcomponent (comp);
if (!e_cal_create_object (client, icalcomp, uid, &error)) {
cl_printf (client, "Object creation: %s\n", error->message);
g_free (comp);
g_free (icalcomp);
return "Test Object Creation failed";
}
e_cal_component_commit_sequence (comp);
if (!e_cal_get_object (client, *uid, NULL, &icalcomp_retrieved, &error)) {
cl_printf (client, "Object retrieval: %s\n", error->message);
g_free (uid);
g_free (comp);
g_free (icalcomp);
return "Test Object Creation failed";
}
comp_retrieved = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (comp_retrieved, icalcomp_retrieved)) {
cl_printf (client, "Could not set icalcomponent\n");
g_free (uid);
g_free (comp);
g_free (icalcomp);
g_free (icalcomp_retrieved);
return "Test Object Creation failed";
}
/* Dumping icalcomp into a string is not useful as the retrieved object
* has some generated information like timestamps. We compare
* member values we set during creation*/
compare = e_cal_component_event_dates_match (comp, comp_retrieved);
if (compare) {
e_cal_component_get_transparency (comp_retrieved, &transp);
compare = (transp == E_CAL_COMPONENT_TRANSP_OPAQUE);
}
g_free (comp_retrieved);
g_free (comp);
g_free (icalcomp);
g_free (icalcomp_retrieved);
mu_assert ("Test Object creation : Created object does not match retrieved data\n", compare);
return NULL;
}
/* Pilot syncing callbacks */
static gint
pre_sync (GnomePilotConduit *conduit,
GnomePilotDBInfo *dbi,
EMemoConduitContext *ctxt)
{
GnomePilotConduitSyncAbs *abs_conduit;
GList *l;
int len;
unsigned char *buf;
char *filename, *change_id;
icalcomponent *icalcomp;
gint num_records, add_records = 0, mod_records = 0, del_records = 0;
#ifdef PILOT_LINK_0_12
pi_buffer_t * buffer;
#endif
abs_conduit = GNOME_PILOT_CONDUIT_SYNC_ABS (conduit);
LOG (g_message ( "---------------------------------------------------------\n" ));
LOG (g_message ( "pre_sync: Memo Conduit v.%s", CONDUIT_VERSION ));
g_message ("Memo Conduit v.%s", CONDUIT_VERSION);
ctxt->dbi = dbi;
ctxt->client = NULL;
if (start_calendar_server (ctxt) != 0) {
WARN(_("Could not start evolution-data-server"));
gnome_pilot_conduit_error (conduit, _("Could not start evolution-data-server"));
return -1;
}
/* Get the timezone */
ctxt->timezone = get_default_timezone ();
if (ctxt->timezone == NULL)
return -1;
LOG (g_message ( " Using timezone: %s", icaltimezone_get_tzid (ctxt->timezone) ));
/* Set the default timezone on the backend. */
if (ctxt->timezone && !e_cal_set_default_timezone (ctxt->client, ctxt->timezone, NULL))
return -1;
/* Get the default component */
if (!e_cal_get_default_object (ctxt->client, &icalcomp, NULL))
return -1;
ctxt->default_comp = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (ctxt->default_comp, icalcomp)) {
g_object_unref (ctxt->default_comp);
icalcomponent_free (icalcomp);
return -1;
}
/* Load the uid <--> pilot id map */
filename = map_name (ctxt);
e_pilot_map_read (filename, &ctxt->map);
g_free (filename);
/* Get the local database */
if (!e_cal_get_object_list_as_comp (ctxt->client, "#t", &ctxt->comps, NULL))
return -1;
/* Count and hash the changes */
change_id = g_strdup_printf ("pilot-sync-evolution-memo-%d", ctxt->cfg->pilot_id);
if (!e_cal_get_changes (ctxt->client, change_id, &ctxt->changed, NULL))
return -1;
ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_free (change_id);
for (l = ctxt->changed; l != NULL; l = l->next) {
ECalChange *ccc = l->data;
const char *uid;
e_cal_component_get_uid (ccc->comp, &uid);
if (!e_pilot_map_uid_is_archived (ctxt->map, uid)) {
g_hash_table_insert (ctxt->changed_hash, g_strdup (uid), ccc);
switch (ccc->type) {
case E_CAL_CHANGE_ADDED:
add_records++;
break;
case E_CAL_CHANGE_MODIFIED:
mod_records++;
break;
case E_CAL_CHANGE_DELETED:
del_records++;
break;
}
} else if (ccc->type == E_CAL_CHANGE_DELETED) {
e_pilot_map_remove_by_uid (ctxt->map, uid);
}
}
/* Set the count information */
num_records = g_list_length (ctxt->comps);
gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records);
gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records);
gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records);
gnome_pilot_conduit_sync_abs_set_num_deleted_local_records(abs_conduit, del_records);
g_message("num_records: %d\nadd_records: %d\nmod_records: %d\ndel_records: %d\n",
num_records, add_records, mod_records, del_records);
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
pi_set_error(dbi->pilot_socket, PI_ERR_GENERIC_MEMORY);
return -1;
}
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
DLP_BUF_SIZE,
buffer);
#else
buf = (unsigned char*)g_malloc (0xffff);
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
(unsigned char *)buf, 0xffff);
#endif
if (len < 0) {
WARN (_("Could not read pilot's Memo application block"));
WARN ("dlp_ReadAppBlock(...) = %d", len);
gnome_pilot_conduit_error (conduit,
_("Could not read pilot's Memo application block"));
return -1;
}
#ifdef PILOT_LINK_0_12
buf = g_new0 (unsigned char,buffer->used);
memcpy(buf, buffer->data, buffer->used);
unpack_MemoAppInfo (&(ctxt->ai), buf, len);
pi_buffer_free(buffer);
#else
unpack_MemoAppInfo (&(ctxt->ai), buf, len);
#endif
g_free (buf);
lastDesktopUniqueID = 128;
check_for_slow_setting (conduit, ctxt);
if (ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyToPilot
|| ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyFromPilot)
ctxt->map->write_touched_only = TRUE;
return 0;
}
static gboolean
do_manage_comp_idle (struct _manage_comp *mc)
{
GError *error = NULL;
ECalClientSourceType source_type = E_CAL_CLIENT_SOURCE_TYPE_LAST;
ECalComponent *edit_comp = NULL;
g_return_val_if_fail (mc, FALSE);
source_type = e_cal_client_get_source_type (mc->client);
if (source_type == E_CAL_CLIENT_SOURCE_TYPE_LAST) {
free_manage_comp_struct (mc);
g_warning ("mail-to-task: Incorrect call of %s, no data given", G_STRFUNC);
return FALSE;
}
if (mc->stored_comp) {
const gchar *ask = get_question_edit_old (source_type);
if (ask) {
gchar *msg = g_strdup_printf (ask, icalcomponent_get_summary (mc->stored_comp) ? icalcomponent_get_summary (mc->stored_comp) : _("[No Summary]"));
gint chosen;
chosen = do_ask (msg, TRUE);
if (chosen == GTK_RESPONSE_YES) {
edit_comp = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (edit_comp, icalcomponent_new_clone (mc->stored_comp))) {
g_object_unref (edit_comp);
edit_comp = NULL;
error = g_error_new (
E_CAL_CLIENT_ERROR,
E_CAL_CLIENT_ERROR_INVALID_OBJECT,
"%s", _("Invalid object returned from a server"));
}
} else if (chosen == GTK_RESPONSE_NO) {
/* user wants to create a new event, thus generate a new UID */
gchar *new_uid = e_cal_component_gen_uid ();
edit_comp = mc->comp;
e_cal_component_set_uid (edit_comp, new_uid);
e_cal_component_set_recurid (edit_comp, NULL);
g_free (new_uid);
}
g_free (msg);
}
} else {
edit_comp = mc->comp;
}
if (edit_comp) {
EShell *shell;
ECompEditor *comp_editor;
/* FIXME Pass in the EShell instance. */
shell = e_shell_get_default ();
comp_editor = get_component_editor (
shell, mc->client, edit_comp,
edit_comp == mc->comp, &error);
if (comp_editor && !error) {
comp_editor_title_changed (GTK_WIDGET (comp_editor), NULL, mc);
e_signal_connect_notify (
comp_editor, "notify::title",
G_CALLBACK (comp_editor_title_changed), mc);
g_signal_connect (
comp_editor, "editor-closed",
G_CALLBACK (comp_editor_closed), mc);
gtk_window_present (GTK_WINDOW (comp_editor));
if (edit_comp != mc->comp)
g_object_unref (edit_comp);
} else {
g_warning ("Failed to create event editor: %s", error ? error->message : "Unknown error");
g_cond_signal (&mc->cond);
}
} else {
/* User canceled editing already existing event, so
* treat it as if he just closed the editor window. */
comp_editor_closed (NULL, FALSE, mc);
}
if (error != NULL) {
e_notice (
NULL, GTK_MESSAGE_ERROR,
_("An error occurred during processing: %s"),
error->message);
g_clear_error (&error);
}
return FALSE;
}
static void
update_cal_entries_cb (EShellView *shell_view,
gpointer user_data)
{
EShellWindow *shell_window;
GtkActionGroup *action_group;
gboolean visible = FALSE, is_unaccepted = FALSE, is_mtg_owner = FALSE;
EShellContent *shell_content;
GnomeCalendar *gcal = NULL;
GnomeCalendarViewType view_type;
ECalendarView *view;
g_return_if_fail (E_IS_SHELL_VIEW (shell_view));
shell_window = e_shell_view_get_shell_window (shell_view);
shell_content = e_shell_view_get_shell_content (shell_view);
g_object_get (shell_content, "calendar", &gcal, NULL);
view_type = gnome_calendar_get_view (gcal);
view = gnome_calendar_get_calendar_view (gcal, view_type);
if (view) {
GList *selected;
selected = e_calendar_view_get_selected_events (view);
if (selected && selected->data) {
ECalendarViewEvent *event = (ECalendarViewEvent *) selected->data;
const gchar *uri;
uri = is_comp_data_valid (event) ? e_client_get_uri (E_CLIENT (event->comp_data->client)) : NULL;
if (uri && g_ascii_strncasecmp (uri, "groupwise://", 12) == 0) {
visible = e_cal_util_component_has_attendee (event->comp_data->icalcomp);
if (visible) {
ECalComponent *comp;
comp = e_cal_component_new ();
e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
if (e_client_check_capability (E_CLIENT (event->comp_data->client), CAL_STATIC_CAPABILITY_HAS_UNACCEPTED_MEETING)) {
gchar *user_email;
user_email = itip_get_comp_attendee (comp, event->comp_data->client);
is_unaccepted = needs_to_accept (event->comp_data->icalcomp, user_email);
g_free (user_email);
}
is_mtg_owner = is_meeting_owner (comp, event->comp_data->client);
g_object_unref (comp);
}
}
}
g_list_free (selected);
}
action_group = e_shell_window_get_action_group (shell_window, "calendar");
visible_actions (action_group, visible, cal_entries, G_N_ELEMENTS (cal_entries));
if (visible && !is_unaccepted) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "gw-meeting-accept");
g_return_if_fail (action != NULL);
gtk_action_set_visible (action, FALSE);
action = gtk_action_group_get_action (action_group, "gw-meeting-accept-tentative");
g_return_if_fail (action != NULL);
gtk_action_set_visible (action, FALSE);
}
if (visible && !is_mtg_owner) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "gw-resend-meeting");
g_return_if_fail (action != NULL);
gtk_action_set_visible (action, FALSE);
}
g_object_unref (gcal);
}
/** Collect recipients from the iTip (based on the METHOD).
*
* To exclude username from the list, pass his name using @a sender
* parameter.
*
* @param icomp iCal component.
* @param sender Username to exclude from the list.
* @param recipients Pointer to the list of recipients' emails. It will be
* appended to.
*/
void icalcomponent_collect_recipients(icalcomponent *icomp, const char *sender, GSList * *recipients)
{
GSList *to_list = NULL, *attendees = NULL, *iter;
ECalComponentOrganizer organizer;
icalproperty_method method;
icalcomponent *payload;
ECalComponent *ecomp = NULL;
payload = icalcomponent_get_itip_payload(icomp);
method = icalcomponent_get_itip_method(icomp);
if (payload == NULL)
{
goto out;
}
ecomp = e_cal_component_new();
e_cal_component_set_icalcomponent(ecomp, icalcomponent_new_clone(payload));
e_cal_component_get_attendee_list(ecomp, &attendees);
e_cal_component_get_organizer(ecomp, &organizer);
if (organizer.value == NULL)
{
goto out;
}
switch (method)
{
case ICAL_METHOD_REQUEST:
case ICAL_METHOD_CANCEL:
for (iter = attendees; iter; iter = iter->next)
{
ECalComponentAttendee *att = iter->data;
if (!g_ascii_strcasecmp(att->value, organizer.value))
{
continue;
}
else if (att->sentby && !g_ascii_strcasecmp(att->sentby, organizer.sentby))
{
continue;
}
else if (!g_ascii_strcasecmp(strip_mailto(att->value), sender))
{
continue;
}
else if (att->status == ICAL_PARTSTAT_DELEGATED && (att->delto && *att->delto)
&& !(att->rsvp) && method == ICAL_METHOD_REQUEST)
{
continue;
}
to_list = g_slist_append(to_list, g_strdup(strip_mailto(att->value)));
}
break;
case ICAL_METHOD_REPLY:
to_list = g_slist_append(to_list, g_strdup(strip_mailto(organizer.value)));
break;
case ICAL_METHOD_ADD:
case ICAL_METHOD_REFRESH:
case ICAL_METHOD_COUNTER:
case ICAL_METHOD_DECLINECOUNTER:
to_list = g_slist_append(to_list, g_strdup(strip_mailto(organizer.value)));
// send the status to delegatee to the delegate also is missing
break;
case ICAL_METHOD_PUBLISH:
default:
break;
}
out:
e_cal_component_free_attendee_list(attendees);
if (ecomp)
{
g_object_unref(ecomp);
}
if (recipients)
{
*recipients = to_list;
}
}
static void
week_view_event_item_draw_icons (EWeekViewEventItem *event_item,
cairo_t *cr,
gint icon_x,
gint icon_y,
gint x2,
gboolean right_align,
cairo_region_t *draw_region)
{
EWeekView *week_view;
EWeekViewEvent *event;
ECalComponent *comp;
GnomeCanvas *canvas;
GtkWidget *parent;
gint num_icons = 0, icon_x_inc;
gboolean draw_reminder_icon = FALSE, draw_recurrence_icon = FALSE;
gboolean draw_timezone_icon = FALSE, draw_attach_icon = FALSE;
gboolean draw_meeting_icon = FALSE;
GSList *categories_pixbufs = NULL, *pixbufs;
canvas = GNOME_CANVAS_ITEM (event_item)->canvas;
parent = gtk_widget_get_parent (GTK_WIDGET (canvas));
week_view = E_WEEK_VIEW (parent);
if (!is_array_index_in_bounds (week_view->events, event_item->priv->event_num))
return;
event = &g_array_index (week_view->events, EWeekViewEvent,
event_item->priv->event_num);
if (!is_comp_data_valid (event))
return;
comp = e_cal_component_new ();
e_cal_component_set_icalcomponent (
comp, icalcomponent_new_clone (event->comp_data->icalcomp));
if (e_cal_component_has_alarms (comp)) {
draw_reminder_icon = TRUE;
num_icons++;
}
if (e_cal_component_has_recurrences (comp) || e_cal_component_is_instance (comp)) {
draw_recurrence_icon = TRUE;
num_icons++;
}
if (e_cal_component_has_attachments (comp)) {
draw_attach_icon = TRUE;
num_icons++;
}
if (e_cal_component_has_attendees (comp)) {
draw_meeting_icon = TRUE;
num_icons++;
}
if (event->different_timezone) {
draw_timezone_icon = TRUE;
num_icons++;
}
num_icons += cal_comp_util_get_n_icons (comp, &categories_pixbufs);
icon_x_inc = E_WEEK_VIEW_ICON_WIDTH + E_WEEK_VIEW_ICON_X_PAD;
if (right_align)
icon_x -= icon_x_inc * num_icons;
#define draw_pixbuf(pf) \
if (can_draw_in_region (draw_region, icon_x, icon_y, \
E_WEEK_VIEW_ICON_WIDTH, E_WEEK_VIEW_ICON_HEIGHT)) { \
cairo_save (cr); \
gdk_cairo_set_source_pixbuf (cr, pf, icon_x, icon_y); \
cairo_paint (cr); \
cairo_restore (cr); \
} \
\
icon_x += icon_x_inc;
if (draw_reminder_icon && icon_x + E_WEEK_VIEW_ICON_WIDTH <= x2) {
draw_pixbuf (week_view->reminder_icon);
}
if (draw_attach_icon && icon_x + E_WEEK_VIEW_ICON_WIDTH <= x2) {
draw_pixbuf (week_view->attach_icon);
}
if (draw_recurrence_icon && icon_x + E_WEEK_VIEW_ICON_WIDTH <= x2) {
draw_pixbuf (week_view->recurrence_icon);
}
if (draw_timezone_icon && icon_x + E_WEEK_VIEW_ICON_WIDTH <= x2) {
draw_pixbuf (week_view->timezone_icon);
}
if (draw_meeting_icon && icon_x + E_WEEK_VIEW_ICON_WIDTH <= x2) {
draw_pixbuf (week_view->meeting_icon);
}
/* draw categories icons */
for (pixbufs = categories_pixbufs;
pixbufs;
pixbufs = pixbufs->next) {
GdkPixbuf *pixbuf = pixbufs->data;
draw_pixbuf (pixbuf);
}
#undef draw_pixbuf
g_slist_foreach (categories_pixbufs, (GFunc) g_object_unref, NULL);
g_slist_free (categories_pixbufs);
g_object_unref (comp);
}
static void
process_meeting (ECalendarView *cal_view, icalparameter_partstat status)
{
GList *selected;
icalcomponent *clone;
selected = e_calendar_view_get_selected_events (cal_view);
if (selected) {
ECalendarViewEvent *event = (ECalendarViewEvent *) selected->data;
ECalComponent *comp = e_cal_component_new ();
ReceiveData *r_data = g_new0 (ReceiveData, 1);
gboolean recurring = FALSE;
GThread *thread = NULL;
GError *error = NULL;
char *address = NULL;
e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
address = itip_get_comp_attendee (comp, event->comp_data->client);
if (e_cal_component_has_recurrences (comp) || e_cal_component_is_instance (comp))
recurring = TRUE;
/* Free comp */
g_object_unref (comp);
comp = NULL;
clone = icalcomponent_new_clone (event->comp_data->icalcomp);
change_status (clone, address, status);
r_data->ecal = g_object_ref (event->comp_data->client);
r_data->icalcomp = clone;
if (recurring) {
gint response;
const char *arg;
if (status == ICAL_PARTSTAT_ACCEPTED || status == ICAL_PARTSTAT_TENTATIVE)
arg = "accept";
else
arg = "decline";
response = e_error_run (NULL, "org.gnome.evolution.mail_shared_folder:recurrence", arg, NULL);
if (response == GTK_RESPONSE_YES) {
icalproperty *prop;
const char *uid = icalcomponent_get_uid (r_data->icalcomp);
prop = icalproperty_new_x ("All");
icalproperty_set_x_name (prop, "X-GW-RECUR-INSTANCES-MOD-TYPE");
icalcomponent_add_property (r_data->icalcomp, prop);
prop = icalproperty_new_x (uid);
icalproperty_set_x_name (prop, "X-GW-RECURRENCE-KEY");
icalcomponent_add_property (r_data->icalcomp, prop);
} else if (response == GTK_RESPONSE_CANCEL) {
finalize_receive_data (r_data);
return;
}
}
thread = g_thread_create ((GThreadFunc) receive_objects, r_data , FALSE, &error);
if (!thread) {
g_warning (G_STRLOC ": %s", error->message);
g_error_free (error);
}
}
}
