/*
* Evolution calendar - Data model for ETable
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see
*
*
* Authors:
* Rodrigo Moya
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#include "comp-util.h"
#include "e-cal-model.h"
#include "itip-utils.h"
#include "misc.h"
struct _ECalModelComponentPrivate {
GString *categories_str;
};
#define E_CAL_MODEL_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_CAL_MODEL, ECalModelPrivate))
#define E_CAL_MODEL_COMPONENT_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE \
((obj), E_TYPE_CAL_MODEL_COMPONENT, ECalModelComponentPrivate))
typedef struct {
ECalClient *client;
ECalClientView *view;
gboolean do_query;
GCancellable *cancellable;
} ECalModelClient;
struct _ECalModelPrivate {
ESourceRegistry *registry;
/* The list of clients we are managing. Each element is of type ECalModelClient */
GList *clients;
/* The default client in the list */
ECalClient *default_client;
/* Array for storing the objects. Each element is of type ECalModelComponent */
GPtrArray *objects;
icalcomponent_kind kind;
ECalModelFlags flags;
icaltimezone *zone;
/* The time range to display */
time_t start;
time_t end;
/* The search regular expression */
gchar *search_sexp;
/* The full regular expression, including time range */
gchar *full_sexp;
/* The default category */
gchar *default_category;
/* Whether we display dates in 24-hour format. */
gboolean use_24_hour_format;
/* Whether to compress weekends into one cell. */
gboolean compress_weekend;
/* First day of the week: 0 (Monday) to 6 (Sunday) */
gint week_start_day;
/* Work day timespan */
gint work_day_start_hour;
gint work_day_start_minute;
gint work_day_end_hour;
gint work_day_end_minute;
/* callback, to retrieve start time for newly added rows by click-to-add */
ECalModelDefaultTimeFunc get_default_time;
gpointer get_default_time_user_data;
/* Default reminder for events */
gboolean use_default_reminder;
gint default_reminder_interval;
EDurationType default_reminder_units;
/* Ask user to confirm before deleting components. */
gboolean confirm_delete;
gboolean in_added;
gboolean in_modified;
gboolean in_removed;
GHashTable *notify_added;
GHashTable *notify_modified;
GHashTable *notify_removed;
GMutex notify_lock;
GCancellable *loading_clients;
};
static gint ecm_column_count (ETableModel *etm);
static gint ecm_row_count (ETableModel *etm);
static gpointer ecm_value_at (ETableModel *etm, gint col, gint row);
static void ecm_set_value_at (ETableModel *etm, gint col, gint row, gconstpointer value);
static gboolean ecm_is_cell_editable (ETableModel *etm, gint col, gint row);
static void ecm_append_row (ETableModel *etm, ETableModel *source, gint row);
static gpointer ecm_duplicate_value (ETableModel *etm, gint col, gconstpointer value);
static void ecm_free_value (ETableModel *etm, gint col, gpointer value);
static gpointer ecm_initialize_value (ETableModel *etm, gint col);
static gboolean ecm_value_is_empty (ETableModel *etm, gint col, gconstpointer value);
static gchar *ecm_value_to_string (ETableModel *etm, gint col, gconstpointer value);
static const gchar *ecm_get_color_for_component (ECalModel *model, ECalModelComponent *comp_data);
static ECalModelClient *add_new_client (ECalModel *model, ECalClient *client, gboolean do_query);
static ECalModelClient *find_client_data (ECalModel *model, ECalClient *client);
static void remove_client_objects (ECalModel *model, ECalModelClient *client_data);
static void remove_client (ECalModel *model, ECalModelClient *client_data);
static void redo_queries (ECalModel *model);
enum {
PROP_0,
PROP_COMPRESS_WEEKEND,
PROP_CONFIRM_DELETE,
PROP_DEFAULT_CLIENT,
PROP_DEFAULT_REMINDER_INTERVAL,
PROP_DEFAULT_REMINDER_UNITS,
PROP_REGISTRY,
PROP_TIMEZONE,
PROP_USE_24_HOUR_FORMAT,
PROP_USE_DEFAULT_REMINDER,
PROP_WEEK_START_DAY,
PROP_WORK_DAY_END_HOUR,
PROP_WORK_DAY_END_MINUTE,
PROP_WORK_DAY_START_HOUR,
PROP_WORK_DAY_START_MINUTE
};
enum {
TIME_RANGE_CHANGED,
ROW_APPENDED,
COMPS_DELETED,
CAL_VIEW_PROGRESS,
CAL_VIEW_COMPLETE,
STATUS_MESSAGE,
TIMEZONE_CHANGED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
G_DEFINE_TYPE_WITH_CODE (
ECalModel, e_cal_model, E_TYPE_TABLE_MODEL,
G_IMPLEMENT_INTERFACE (E_TYPE_EXTENSIBLE, NULL))
G_DEFINE_TYPE (
ECalModelComponent,
e_cal_model_component,
G_TYPE_OBJECT)
static void
cal_model_set_registry (ECalModel *model,
ESourceRegistry *registry)
{
g_return_if_fail (E_IS_SOURCE_REGISTRY (registry));
g_return_if_fail (model->priv->registry == NULL);
model->priv->registry = g_object_ref (registry);
}
static void
cal_model_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_COMPRESS_WEEKEND:
e_cal_model_set_compress_weekend (
E_CAL_MODEL (object),
g_value_get_boolean (value));
return;
case PROP_CONFIRM_DELETE:
e_cal_model_set_confirm_delete (
E_CAL_MODEL (object),
g_value_get_boolean (value));
return;
case PROP_DEFAULT_CLIENT:
e_cal_model_set_default_client (
E_CAL_MODEL (object),
g_value_get_object (value));
return;
case PROP_DEFAULT_REMINDER_INTERVAL:
e_cal_model_set_default_reminder_interval (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
case PROP_DEFAULT_REMINDER_UNITS:
e_cal_model_set_default_reminder_units (
E_CAL_MODEL (object),
g_value_get_enum (value));
return;
case PROP_REGISTRY:
cal_model_set_registry (
E_CAL_MODEL (object),
g_value_get_object (value));
return;
case PROP_TIMEZONE:
e_cal_model_set_timezone (
E_CAL_MODEL (object),
g_value_get_pointer (value));
return;
case PROP_USE_24_HOUR_FORMAT:
e_cal_model_set_use_24_hour_format (
E_CAL_MODEL (object),
g_value_get_boolean (value));
return;
case PROP_USE_DEFAULT_REMINDER:
e_cal_model_set_use_default_reminder (
E_CAL_MODEL (object),
g_value_get_boolean (value));
return;
case PROP_WEEK_START_DAY:
e_cal_model_set_week_start_day (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
case PROP_WORK_DAY_END_HOUR:
e_cal_model_set_work_day_end_hour (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
case PROP_WORK_DAY_END_MINUTE:
e_cal_model_set_work_day_end_minute (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
case PROP_WORK_DAY_START_HOUR:
e_cal_model_set_work_day_start_hour (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
case PROP_WORK_DAY_START_MINUTE:
e_cal_model_set_work_day_start_minute (
E_CAL_MODEL (object),
g_value_get_int (value));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
cal_model_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
switch (property_id) {
case PROP_COMPRESS_WEEKEND:
g_value_set_boolean (
value,
e_cal_model_get_compress_weekend (
E_CAL_MODEL (object)));
return;
case PROP_CONFIRM_DELETE:
g_value_set_boolean (
value,
e_cal_model_get_confirm_delete (
E_CAL_MODEL (object)));
return;
case PROP_DEFAULT_CLIENT:
g_value_set_object (
value,
e_cal_model_get_default_client (
E_CAL_MODEL (object)));
return;
case PROP_DEFAULT_REMINDER_INTERVAL:
g_value_set_int (
value,
e_cal_model_get_default_reminder_interval (
E_CAL_MODEL (object)));
return;
case PROP_DEFAULT_REMINDER_UNITS:
g_value_set_enum (
value,
e_cal_model_get_default_reminder_units (
E_CAL_MODEL (object)));
return;
case PROP_REGISTRY:
g_value_set_object (
value,
e_cal_model_get_registry (
E_CAL_MODEL (object)));
return;
case PROP_TIMEZONE:
g_value_set_pointer (
value,
e_cal_model_get_timezone (
E_CAL_MODEL (object)));
return;
case PROP_USE_24_HOUR_FORMAT:
g_value_set_boolean (
value,
e_cal_model_get_use_24_hour_format (
E_CAL_MODEL (object)));
return;
case PROP_USE_DEFAULT_REMINDER:
g_value_set_boolean (
value,
e_cal_model_get_use_default_reminder (
E_CAL_MODEL (object)));
return;
case PROP_WEEK_START_DAY:
g_value_set_int (
value,
e_cal_model_get_week_start_day (
E_CAL_MODEL (object)));
return;
case PROP_WORK_DAY_END_HOUR:
g_value_set_int (
value,
e_cal_model_get_work_day_end_hour (
E_CAL_MODEL (object)));
return;
case PROP_WORK_DAY_END_MINUTE:
g_value_set_int (
value,
e_cal_model_get_work_day_end_minute (
E_CAL_MODEL (object)));
return;
case PROP_WORK_DAY_START_HOUR:
g_value_set_int (
value,
e_cal_model_get_work_day_start_hour (
E_CAL_MODEL (object)));
return;
case PROP_WORK_DAY_START_MINUTE:
g_value_set_int (
value,
e_cal_model_get_work_day_start_minute (
E_CAL_MODEL (object)));
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
cal_model_constructed (GObject *object)
{
e_extensible_load_extensions (E_EXTENSIBLE (object));
/* Chain up to parent's constructed() method. */
G_OBJECT_CLASS (e_cal_model_parent_class)->constructed (object);
}
static void
cal_model_dispose (GObject *object)
{
ECalModelPrivate *priv;
priv = E_CAL_MODEL_GET_PRIVATE (object);
if (priv->registry != NULL) {
g_object_unref (priv->registry);
priv->registry = NULL;
}
if (priv->loading_clients) {
g_cancellable_cancel (priv->loading_clients);
g_object_unref (priv->loading_clients);
priv->loading_clients = NULL;
}
if (priv->clients) {
while (priv->clients != NULL) {
ECalModelClient *client_data = (ECalModelClient *) priv->clients->data;
g_signal_handlers_disconnect_matched (client_data->client, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, object);
if (client_data->view)
g_signal_handlers_disconnect_matched (client_data->view, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, object);
priv->clients = g_list_remove (priv->clients, client_data);
g_object_unref (client_data->client);
if (client_data->cancellable) {
g_cancellable_cancel (client_data->cancellable);
g_object_unref (client_data->cancellable);
}
if (client_data->view)
g_object_unref (client_data->view);
g_free (client_data);
}
priv->clients = NULL;
priv->default_client = NULL;
}
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (e_cal_model_parent_class)->dispose (object);
}
static void
cal_model_finalize (GObject *object)
{
ECalModelPrivate *priv;
gint ii;
priv = E_CAL_MODEL_GET_PRIVATE (object);
g_free (priv->search_sexp);
g_free (priv->full_sexp);
g_free (priv->default_category);
for (ii = 0; ii < priv->objects->len; ii++) {
ECalModelComponent *comp_data;
comp_data = g_ptr_array_index (priv->objects, ii);
if (comp_data == NULL) {
g_warning ("comp_data is null\n");
continue;
}
g_object_unref (comp_data);
}
g_ptr_array_free (priv->objects, FALSE);
g_mutex_clear (&priv->notify_lock);
g_hash_table_destroy (priv->notify_added);
g_hash_table_destroy (priv->notify_modified);
g_hash_table_destroy (priv->notify_removed);
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (e_cal_model_parent_class)->finalize (object);
}
static void
e_cal_model_class_init (ECalModelClass *class)
{
GObjectClass *object_class;
ETableModelClass *etm_class;
g_type_class_add_private (class, sizeof (ECalModelPrivate));
object_class = G_OBJECT_CLASS (class);
object_class->set_property = cal_model_set_property;
object_class->get_property = cal_model_get_property;
object_class->constructed = cal_model_constructed;
object_class->dispose = cal_model_dispose;
object_class->finalize = cal_model_finalize;
etm_class = E_TABLE_MODEL_CLASS (class);
etm_class->column_count = ecm_column_count;
etm_class->row_count = ecm_row_count;
etm_class->value_at = ecm_value_at;
etm_class->set_value_at = ecm_set_value_at;
etm_class->is_cell_editable = ecm_is_cell_editable;
etm_class->append_row = ecm_append_row;
etm_class->duplicate_value = ecm_duplicate_value;
etm_class->free_value = ecm_free_value;
etm_class->initialize_value = ecm_initialize_value;
etm_class->value_is_empty = ecm_value_is_empty;
etm_class->value_to_string = ecm_value_to_string;
class->get_color_for_component = ecm_get_color_for_component;
class->fill_component_from_model = NULL;
g_object_class_install_property (
object_class,
PROP_COMPRESS_WEEKEND,
g_param_spec_boolean (
"compress-weekend",
"Compress Weekend",
NULL,
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_CONFIRM_DELETE,
g_param_spec_boolean (
"confirm-delete",
"Confirm Delete",
NULL,
TRUE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_DEFAULT_CLIENT,
g_param_spec_object (
"default-client",
"Default ECalClient",
NULL,
E_TYPE_CAL_CLIENT,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_DEFAULT_REMINDER_INTERVAL,
g_param_spec_int (
"default-reminder-interval",
"Default Reminder Interval",
NULL,
G_MININT,
G_MAXINT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_DEFAULT_REMINDER_UNITS,
g_param_spec_enum (
"default-reminder-units",
"Default Reminder Units",
NULL,
E_TYPE_DURATION_TYPE,
E_DURATION_MINUTES,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_REGISTRY,
g_param_spec_object (
"registry",
"Registry",
"Data source registry",
E_TYPE_SOURCE_REGISTRY,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property (
object_class,
PROP_TIMEZONE,
g_param_spec_pointer (
"timezone",
"Time Zone",
NULL,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_USE_24_HOUR_FORMAT,
g_param_spec_boolean (
"use-24-hour-format",
"Use 24-Hour Format",
NULL,
TRUE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_USE_DEFAULT_REMINDER,
g_param_spec_boolean (
"use-default-reminder",
"Use Default Reminder",
NULL,
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_WEEK_START_DAY,
g_param_spec_int (
"week-start-day",
"Week Start Day",
NULL,
0, /* Monday */
6, /* Sunday */
0,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_WORK_DAY_END_HOUR,
g_param_spec_int (
"work-day-end-hour",
"Work Day End Hour",
NULL,
0,
23,
0,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_WORK_DAY_END_MINUTE,
g_param_spec_int (
"work-day-end-minute",
"Work Day End Minute",
NULL,
0,
59,
0,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_WORK_DAY_START_HOUR,
g_param_spec_int (
"work-day-start-hour",
"Work Day Start Hour",
NULL,
0,
23,
0,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_WORK_DAY_START_MINUTE,
g_param_spec_int (
"work-day-start-minute",
"Work Day Start Minute",
NULL,
0,
59,
0,
G_PARAM_READWRITE));
signals[TIME_RANGE_CHANGED] =
g_signal_new ("time_range_changed",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, time_range_changed),
NULL, NULL,
e_marshal_VOID__LONG_LONG,
G_TYPE_NONE, 2, G_TYPE_LONG, G_TYPE_LONG);
signals[ROW_APPENDED] =
g_signal_new ("row_appended",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, row_appended),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[COMPS_DELETED] =
g_signal_new ("comps_deleted",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, comps_deleted),
NULL, NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_POINTER);
signals[CAL_VIEW_PROGRESS] =
g_signal_new ("cal_view_progress",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, cal_view_progress),
NULL, NULL,
e_marshal_VOID__STRING_INT_INT,
G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
signals[CAL_VIEW_COMPLETE] =
g_signal_new ("cal_view_complete",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, cal_view_complete),
NULL, NULL,
e_marshal_VOID__BOXED_INT,
G_TYPE_NONE, 2, G_TYPE_ERROR, G_TYPE_INT);
signals[STATUS_MESSAGE] = g_signal_new (
"status-message",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (ECalModelClass, status_message),
NULL, NULL,
e_marshal_VOID__STRING_DOUBLE,
G_TYPE_NONE, 2,
G_TYPE_STRING, G_TYPE_DOUBLE);
signals[TIMEZONE_CHANGED] = g_signal_new (
"timezone-changed",
G_TYPE_FROM_CLASS (class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ECalModelClass, timezone_changed),
NULL, NULL,
e_marshal_VOID__POINTER_POINTER,
G_TYPE_NONE, 2,
G_TYPE_POINTER,
G_TYPE_POINTER);
}
static void
e_cal_model_init (ECalModel *model)
{
model->priv = E_CAL_MODEL_GET_PRIVATE (model);
/* match none by default */
model->priv->start = -1;
model->priv->end = -1;
model->priv->search_sexp = NULL;
model->priv->full_sexp = g_strdup ("#f");
model->priv->objects = g_ptr_array_new ();
model->priv->kind = ICAL_NO_COMPONENT;
model->priv->flags = 0;
model->priv->use_24_hour_format = TRUE;
model->priv->in_added = FALSE;
model->priv->in_modified = FALSE;
model->priv->in_removed = FALSE;
model->priv->notify_added = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);
model->priv->notify_modified = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);
model->priv->notify_removed = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);
g_mutex_init (&model->priv->notify_lock);
model->priv->loading_clients = g_cancellable_new ();
}
/* ETableModel methods */
static gint
ecm_column_count (ETableModel *etm)
{
return E_CAL_MODEL_FIELD_LAST;
}
static gint
ecm_row_count (ETableModel *etm)
{
ECalModelPrivate *priv;
ECalModel *model = (ECalModel *) etm;
g_return_val_if_fail (E_IS_CAL_MODEL (model), -1);
priv = model->priv;
return priv->objects->len;
}
static gpointer
get_categories (ECalModelComponent *comp_data)
{
if (!comp_data->priv->categories_str) {
icalproperty *prop;
comp_data->priv->categories_str = g_string_new ("");
for (prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY);
prop;
prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY)) {
const gchar *categories = icalproperty_get_categories (prop);
if (!categories)
continue;
if (comp_data->priv->categories_str->len)
g_string_append_c (comp_data->priv->categories_str, ',');
g_string_append (comp_data->priv->categories_str, categories);
}
}
return comp_data->priv->categories_str->str;
}
static gchar *
get_classification (ECalModelComponent *comp_data)
{
icalproperty *prop;
icalproperty_class class;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY);
if (!prop)
return _("Public");
class = icalproperty_get_class (prop);
switch (class)
{
case ICAL_CLASS_PUBLIC:
return _("Public");
case ICAL_CLASS_PRIVATE:
return _("Private");
case ICAL_CLASS_CONFIDENTIAL:
return _("Confidential");
default:
return _("Unknown");
}
}
static const gchar *
get_color (ECalModel *model,
ECalModelComponent *comp_data)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
return e_cal_model_get_color_for_component (model, comp_data);
}
static gpointer
get_description (ECalModelComponent *comp_data)
{
icalproperty *prop;
static GString *str = NULL;
if (str) {
g_string_free (str, TRUE);
str = NULL;
}
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY);
if (prop) {
str = g_string_new (NULL);
do {
str = g_string_append (str, icalproperty_get_description (prop));
} while ((prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY)));
return str->str;
}
return (gpointer) "";
}
static ECellDateEditValue *
get_dtstart (ECalModel *model,
ECalModelComponent *comp_data)
{
ECalModelPrivate *priv;
struct icaltimetype tt_start;
priv = model->priv;
if (!comp_data->dtstart) {
icalproperty *prop;
icaltimezone *zone;
gboolean got_zone = FALSE;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY);
if (!prop)
return NULL;
tt_start = icalproperty_get_dtstart (prop);
if (icaltime_get_tzid (tt_start)
&& e_cal_client_get_timezone_sync (comp_data->client, icaltime_get_tzid (tt_start), &zone, NULL, NULL))
got_zone = TRUE;
if (e_cal_model_get_flags (model) & E_CAL_MODEL_FLAGS_EXPAND_RECURRENCES) {
if (got_zone) {
tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, zone);
if (priv->zone)
icaltimezone_convert_time (&tt_start, zone, priv->zone);
} else
if (priv->zone)
tt_start = icaltime_from_timet_with_zone (comp_data->instance_start, tt_start.is_date, priv->zone);
}
if (!icaltime_is_valid_time (tt_start) || icaltime_is_null_time (tt_start))
return NULL;
comp_data->dtstart = g_new0 (ECellDateEditValue, 1);
comp_data->dtstart->tt = tt_start;
if (got_zone)
comp_data->dtstart->zone = zone;
else
comp_data->dtstart->zone = NULL;
}
return comp_data->dtstart;
}
static ECellDateEditValue *
get_datetime_from_utc (ECalModel *model,
ECalModelComponent *comp_data,
icalproperty_kind propkind,
struct icaltimetype (*get_value) (const icalproperty *prop),
ECellDateEditValue **buffer)
{
ECalModelPrivate *priv;
struct icaltimetype tt_value;
icalproperty *prop;
ECellDateEditValue *res;
g_return_val_if_fail (buffer!= NULL, NULL);
if (*buffer)
return *buffer;
priv = model->priv;
prop = icalcomponent_get_first_property (comp_data->icalcomp, propkind);
if (!prop)
return NULL;
tt_value = get_value (prop);
/* these are always in UTC, thus convert to default zone, if any and done */
if (priv->zone)
icaltimezone_convert_time (&tt_value, icaltimezone_get_utc_timezone (), priv->zone);
if (!icaltime_is_valid_time (tt_value) || icaltime_is_null_time (tt_value))
return NULL;
res = g_new0 (ECellDateEditValue, 1);
res->tt = tt_value;
res->zone = NULL;
*buffer = res;
return res;
}
static gpointer
get_summary (ECalModelComponent *comp_data)
{
icalproperty *prop;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_SUMMARY_PROPERTY);
if (prop)
return (gpointer) icalproperty_get_summary (prop);
return (gpointer) "";
}
static gchar *
get_uid (ECalModelComponent *comp_data)
{
return (gchar *) icalcomponent_get_uid (comp_data->icalcomp);
}
static gpointer
ecm_value_at (ETableModel *etm,
gint col,
gint row)
{
ECalModelPrivate *priv;
ECalModelComponent *comp_data;
ECalModel *model = (ECalModel *) etm;
ESourceRegistry *registry;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
registry = e_cal_model_get_registry (model);
g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL);
g_return_val_if_fail (row >= 0 && row < priv->objects->len, NULL);
comp_data = g_ptr_array_index (priv->objects, row);
g_return_val_if_fail (comp_data != NULL, NULL);
g_return_val_if_fail (comp_data->icalcomp != NULL, NULL);
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
return get_categories (comp_data);
case E_CAL_MODEL_FIELD_CLASSIFICATION :
return get_classification (comp_data);
case E_CAL_MODEL_FIELD_COLOR :
return (gpointer) get_color (model, comp_data);
case E_CAL_MODEL_FIELD_COMPONENT :
return comp_data->icalcomp;
case E_CAL_MODEL_FIELD_DESCRIPTION :
return get_description (comp_data);
case E_CAL_MODEL_FIELD_DTSTART :
return (gpointer) get_dtstart (model, comp_data);
case E_CAL_MODEL_FIELD_CREATED :
return (gpointer) get_datetime_from_utc (model, comp_data, ICAL_CREATED_PROPERTY, icalproperty_get_created, &comp_data->created);
case E_CAL_MODEL_FIELD_LASTMODIFIED :
return (gpointer) get_datetime_from_utc (model, comp_data, ICAL_LASTMODIFIED_PROPERTY, icalproperty_get_lastmodified, &comp_data->lastmodified);
case E_CAL_MODEL_FIELD_HAS_ALARMS :
return GINT_TO_POINTER ((icalcomponent_get_first_component (comp_data->icalcomp,
ICAL_VALARM_COMPONENT) != NULL));
case E_CAL_MODEL_FIELD_ICON :
{
ECalComponent *comp;
icalcomponent *icalcomp;
gint retval = 0;
comp = e_cal_component_new ();
icalcomp = icalcomponent_new_clone (comp_data->icalcomp);
if (e_cal_component_set_icalcomponent (comp, icalcomp)) {
if (e_cal_component_get_vtype (comp) == E_CAL_COMPONENT_JOURNAL) {
g_object_unref (comp);
return GINT_TO_POINTER (retval);
}
if (e_cal_component_has_recurrences (comp))
retval = 1;
else if (itip_organizer_is_user (registry, comp, comp_data->client))
retval = 3;
else {
GSList *attendees = NULL, *sl;
e_cal_component_get_attendee_list (comp, &attendees);
for (sl = attendees; sl != NULL; sl = sl->next) {
ECalComponentAttendee *ca = sl->data;
const gchar *text;
text = itip_strip_mailto (ca->value);
if (itip_address_is_user (registry, text)) {
if (ca->delto != NULL)
retval = 3;
else
retval = 2;
break;
}
}
e_cal_component_free_attendee_list (attendees);
}
} else
icalcomponent_free (icalcomp);
g_object_unref (comp);
return GINT_TO_POINTER (retval);
}
case E_CAL_MODEL_FIELD_SUMMARY :
return get_summary (comp_data);
case E_CAL_MODEL_FIELD_UID :
return get_uid (comp_data);
}
return (gpointer) "";
}
static void
set_categories (ECalModelComponent *comp_data,
const gchar *value)
{
icalproperty *prop;
/* remove all categories first */
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY);
while (prop) {
icalproperty *to_remove = prop;
prop = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_CATEGORIES_PROPERTY);
icalcomponent_remove_property (comp_data->icalcomp, to_remove);
icalproperty_free (to_remove);
}
if (comp_data->priv->categories_str)
g_string_free (comp_data->priv->categories_str, TRUE);
comp_data->priv->categories_str = NULL;
/* then set a new value; no need to populate categories_str,
* it'll be populated on demand (in the get_categories() function)
*/
if (value && *value) {
prop = icalproperty_new_categories (value);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
}
static void
set_classification (ECalModelComponent *comp_data,
const gchar *value)
{
icalproperty *prop;
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_CLASS_PROPERTY);
if (!value || !(*value)) {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
} else {
icalproperty_class ical_class;
if (!g_ascii_strcasecmp (value, "PUBLIC"))
ical_class = ICAL_CLASS_PUBLIC;
else if (!g_ascii_strcasecmp (value, "PRIVATE"))
ical_class = ICAL_CLASS_PRIVATE;
else if (!g_ascii_strcasecmp (value, "CONFIDENTIAL"))
ical_class = ICAL_CLASS_CONFIDENTIAL;
else
ical_class = ICAL_CLASS_NONE;
if (!prop) {
prop = icalproperty_new_class (ical_class);
icalcomponent_add_property (comp_data->icalcomp, prop);
} else
icalproperty_set_class (prop, ical_class);
}
}
static void
set_description (ECalModelComponent *comp_data,
const gchar *value)
{
icalproperty *prop;
/* remove old description(s) */
prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY);
while (prop) {
icalproperty *next;
next = icalcomponent_get_next_property (comp_data->icalcomp, ICAL_DESCRIPTION_PROPERTY);
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
prop = next;
}
/* now add the new description */
if (!value || !(*value))
return;
prop = icalproperty_new_description (value);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
static void
datetime_to_zone (ECalClient *client,
struct icaltimetype *tt,
icaltimezone *tt_zone,
const gchar *tzid)
{
icaltimezone *from, *to;
const gchar *tt_tzid = NULL;
g_return_if_fail (tt != NULL);
if (tt_zone)
tt_tzid = icaltimezone_get_tzid (tt_zone);
if (tt_tzid == NULL || tzid == NULL ||
tt_tzid == tzid || g_str_equal (tt_tzid, tzid))
return;
from = tt_zone;
to = icaltimezone_get_builtin_timezone_from_tzid (tzid);
if (!to) {
/* do not check failure here, maybe the zone is not available there */
e_cal_client_get_timezone_sync (client, tzid, &to, NULL, NULL);
}
icaltimezone_convert_time (tt, from, to);
}
/* updates time in a component, and keeps the timezone used in it, if exists */
void
e_cal_model_update_comp_time (ECalModel *model,
ECalModelComponent *comp_data,
gconstpointer time_value,
icalproperty_kind kind,
void (*set_func) (icalproperty *prop,
struct icaltimetype v),
icalproperty * (*new_func) (struct icaltimetype v))
{
ECellDateEditValue *dv = (ECellDateEditValue *) time_value;
icalproperty *prop;
icalparameter *param;
struct icaltimetype tt;
g_return_if_fail (model != NULL);
g_return_if_fail (comp_data != NULL);
g_return_if_fail (set_func != NULL);
g_return_if_fail (new_func != NULL);
prop = icalcomponent_get_first_property (comp_data->icalcomp, kind);
if (prop)
param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
else
param = NULL;
/* If we are setting the property to NULL (i.e. removing it), then
* we remove it if it exists. */
if (!dv) {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
return;
}
tt = dv->tt;
datetime_to_zone (comp_data->client, &tt, e_cal_model_get_timezone (model), param ? icalparameter_get_tzid (param) : NULL);
if (prop) {
set_func (prop, tt);
} else {
prop = new_func (tt);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
if (param) {
const gchar *tzid = icalparameter_get_tzid (param);
/* If the TZID is set to "UTC", we don't want to save the TZID. */
if (tzid && strcmp (tzid, "UTC")) {
if (param) {
icalparameter_set_tzid (param, (gchar *) tzid);
} else {
param = icalparameter_new_tzid ((gchar *) tzid);
icalproperty_add_parameter (prop, param);
}
} else {
icalproperty_remove_parameter (prop, ICAL_TZID_PARAMETER);
}
}
}
static void
set_dtstart (ECalModel *model,
ECalModelComponent *comp_data,
gconstpointer value)
{
e_cal_model_update_comp_time (
model, comp_data, value,
ICAL_DTSTART_PROPERTY,
icalproperty_set_dtstart,
icalproperty_new_dtstart);
}
static void
set_summary (ECalModelComponent *comp_data,
const gchar *value)
{
icalproperty *prop;
prop = icalcomponent_get_first_property (
comp_data->icalcomp, ICAL_SUMMARY_PROPERTY);
if (string_is_empty (value)) {
if (prop) {
icalcomponent_remove_property (comp_data->icalcomp, prop);
icalproperty_free (prop);
}
} else {
if (prop)
icalproperty_set_summary (prop, value);
else {
prop = icalproperty_new_summary (value);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
}
}
static void
ecm_set_value_at (ETableModel *etm,
gint col,
gint row,
gconstpointer value)
{
ECalModelPrivate *priv;
ECalModelComponent *comp_data;
ECalModel *model = (ECalModel *) etm;
GError *error = NULL;
g_return_if_fail (E_IS_CAL_MODEL (model));
priv = model->priv;
g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST);
g_return_if_fail (row >= 0 && row < priv->objects->len);
comp_data = g_ptr_array_index (priv->objects, row);
g_return_if_fail (comp_data != NULL);
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
set_categories (comp_data, value);
break;
case E_CAL_MODEL_FIELD_CLASSIFICATION :
set_classification (comp_data, value);
break;
case E_CAL_MODEL_FIELD_DESCRIPTION :
set_description (comp_data, value);
break;
case E_CAL_MODEL_FIELD_DTSTART :
set_dtstart (model, comp_data, value);
break;
case E_CAL_MODEL_FIELD_SUMMARY :
set_summary (comp_data, value);
break;
}
/* FIXME ask about mod type */
if (!e_cal_client_modify_object_sync (comp_data->client, comp_data->icalcomp, CALOBJ_MOD_ALL, NULL, &error)) {
g_warning (G_STRLOC ": Could not modify the object! %s", error ? error->message : "Unknown error");
/* FIXME Show error dialog */
if (error)
g_error_free (error);
}
}
/**
* e_cal_model_test_row_editable
* @model: an #ECalModel
* @row: Row of our interest. -1 is editable only when default client is
* editable.
*
* Checks if component at @row is editable or not. It doesn't check bounds
* for @row.
*
* Returns: Whether @row is editable or not.
**/
gboolean
e_cal_model_test_row_editable (ECalModel *model,
gint row)
{
gboolean readonly;
ECalClient *client = NULL;
if (row != -1) {
ECalModelComponent *comp_data;
comp_data = e_cal_model_get_component_at (model, row);
if (comp_data)
client = comp_data->client;
} else {
client = e_cal_model_get_default_client (model);
}
readonly = client == NULL;
if (!readonly)
readonly = e_client_is_readonly (E_CLIENT (client));
return !readonly;
}
static gboolean
ecm_is_cell_editable (ETableModel *etm,
gint col,
gint row)
{
ECalModelPrivate *priv;
ECalModel *model = (ECalModel *) etm;
g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE);
priv = model->priv;
g_return_val_if_fail (col >= 0 && col <= E_CAL_MODEL_FIELD_LAST, FALSE);
g_return_val_if_fail (row >= -1 || (row >= 0 && row < priv->objects->len), FALSE);
if (!e_cal_model_test_row_editable (E_CAL_MODEL (etm), row))
return FALSE;
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_SUMMARY :
return TRUE;
}
return FALSE;
}
static void
ecm_append_row (ETableModel *etm,
ETableModel *source,
gint row)
{
ECalModelClass *model_class;
ECalModelComponent *comp_data;
ECalModel *model = (ECalModel *) etm;
gchar *uid = NULL;
GError *error = NULL;
g_return_if_fail (E_IS_CAL_MODEL (model));
g_return_if_fail (E_IS_TABLE_MODEL (source));
comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL);
comp_data->client = e_cal_model_get_default_client (model);
if (comp_data->client)
g_object_ref (comp_data->client);
/* guard against saving before the calendar is open */
if (!comp_data->client || !e_client_is_opened (E_CLIENT (comp_data->client))) {
g_object_unref (comp_data);
return;
}
comp_data->icalcomp = e_cal_model_create_component_with_defaults (model, FALSE);
/* set values for our fields */
set_categories (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CATEGORIES, row));
set_classification (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_CLASSIFICATION, row));
set_description (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DESCRIPTION, row));
set_summary (comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_SUMMARY, row));
if (e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row)) {
set_dtstart (model, comp_data, e_table_model_value_at (source, E_CAL_MODEL_FIELD_DTSTART, row));
} else if (model->priv->get_default_time) {
time_t tt = model->priv->get_default_time (model, model->priv->get_default_time_user_data);
if (tt > 0) {
struct icaltimetype itt = icaltime_from_timet_with_zone (tt, FALSE, e_cal_model_get_timezone (model));
icalproperty *prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY);
if (prop) {
icalproperty_set_dtstart (prop, itt);
} else {
prop = icalproperty_new_dtstart (itt);
icalcomponent_add_property (comp_data->icalcomp, prop);
}
}
}
/* call the class' method for filling the component */
model_class = (ECalModelClass *) G_OBJECT_GET_CLASS (model);
if (model_class->fill_component_from_model != NULL) {
model_class->fill_component_from_model (model, comp_data, source, row);
}
if (!e_cal_client_create_object_sync (comp_data->client, comp_data->icalcomp, &uid, NULL, &error)) {
g_warning (G_STRLOC ": Could not create the object! %s", error ? error->message : "Unknown error");
/* FIXME: show error dialog */
if (error)
g_error_free (error);
} else {
if (uid)
icalcomponent_set_uid (comp_data->icalcomp, uid);
g_signal_emit (G_OBJECT (model), signals[ROW_APPENDED], 0);
}
g_free (uid);
g_object_unref (comp_data);
}
static gpointer
ecm_duplicate_value (ETableModel *etm,
gint col,
gconstpointer value)
{
g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL);
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_SUMMARY :
return g_strdup (value);
case E_CAL_MODEL_FIELD_HAS_ALARMS :
case E_CAL_MODEL_FIELD_ICON :
case E_CAL_MODEL_FIELD_COLOR :
return (gpointer) value;
case E_CAL_MODEL_FIELD_COMPONENT :
return icalcomponent_new_clone ((icalcomponent *) value);
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_CREATED :
case E_CAL_MODEL_FIELD_LASTMODIFIED :
if (value) {
ECellDateEditValue *dv, *orig_dv;
orig_dv = (ECellDateEditValue *) value;
dv = g_new0 (ECellDateEditValue, 1);
*dv = *orig_dv;
return dv;
}
break;
}
return NULL;
}
static void
ecm_free_value (ETableModel *etm,
gint col,
gpointer value)
{
g_return_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST);
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_SUMMARY :
if (value)
g_free (value);
break;
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_HAS_ALARMS :
case E_CAL_MODEL_FIELD_ICON :
case E_CAL_MODEL_FIELD_COLOR :
break;
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_CREATED :
case E_CAL_MODEL_FIELD_LASTMODIFIED :
if (value)
g_free (value);
break;
case E_CAL_MODEL_FIELD_COMPONENT :
if (value)
icalcomponent_free ((icalcomponent *) value);
break;
}
}
static gpointer
ecm_initialize_value (ETableModel *etm,
gint col)
{
ECalModelPrivate *priv;
ECalModel *model = (ECalModel *) etm;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, NULL);
priv = model->priv;
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
return g_strdup (priv->default_category ? priv->default_category:"");
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_SUMMARY :
return g_strdup ("");
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_CREATED :
case E_CAL_MODEL_FIELD_LASTMODIFIED :
case E_CAL_MODEL_FIELD_HAS_ALARMS :
case E_CAL_MODEL_FIELD_ICON :
case E_CAL_MODEL_FIELD_COLOR :
case E_CAL_MODEL_FIELD_COMPONENT :
return NULL;
}
return NULL;
}
static gboolean
ecm_value_is_empty (ETableModel *etm,
gint col,
gconstpointer value)
{
ECalModelPrivate *priv;
ECalModel *model = (ECalModel *) etm;
g_return_val_if_fail (E_IS_CAL_MODEL (model), TRUE);
g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, TRUE);
priv = model->priv;
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
/* This could be a hack or not. If the categories field only
* contains the default category, then it possibly means that
* the user has not entered anything at all in the click-to-add;
* the category is in the value because we put it there in
* ecm_initialize_value().
*/
if (priv->default_category && value && strcmp (priv->default_category, value) == 0)
return TRUE;
else
return string_is_empty (value);
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_SUMMARY :
return string_is_empty (value);
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_CREATED :
case E_CAL_MODEL_FIELD_LASTMODIFIED :
return value ? FALSE : TRUE;
case E_CAL_MODEL_FIELD_HAS_ALARMS :
case E_CAL_MODEL_FIELD_ICON :
case E_CAL_MODEL_FIELD_COLOR :
case E_CAL_MODEL_FIELD_COMPONENT :
return TRUE;
}
return TRUE;
}
static gchar *
ecm_value_to_string (ETableModel *etm,
gint col,
gconstpointer value)
{
g_return_val_if_fail (col >= 0 && col < E_CAL_MODEL_FIELD_LAST, g_strdup (""));
switch (col) {
case E_CAL_MODEL_FIELD_CATEGORIES :
case E_CAL_MODEL_FIELD_CLASSIFICATION :
case E_CAL_MODEL_FIELD_DESCRIPTION :
case E_CAL_MODEL_FIELD_SUMMARY :
return g_strdup (value);
case E_CAL_MODEL_FIELD_DTSTART :
case E_CAL_MODEL_FIELD_CREATED :
case E_CAL_MODEL_FIELD_LASTMODIFIED :
return e_cal_model_date_value_to_string (E_CAL_MODEL (etm), value);
case E_CAL_MODEL_FIELD_ICON :
if (GPOINTER_TO_INT (value) == 0)
return g_strdup (_("Normal"));
else if (GPOINTER_TO_INT (value) == 1)
return g_strdup (_("Recurring"));
else
return g_strdup (_("Assigned"));
case E_CAL_MODEL_FIELD_HAS_ALARMS :
return g_strdup (value ? _("Yes") : _("No"));
case E_CAL_MODEL_FIELD_COLOR :
case E_CAL_MODEL_FIELD_COMPONENT :
return g_strdup ("");
}
return g_strdup ("");
}
/* ECalModel class methods */
typedef struct {
const gchar *color;
GList *uids;
} AssignedColorData;
static const gchar *
ecm_get_color_for_component (ECalModel *model,
ECalModelComponent *comp_data)
{
ESource *source;
ESourceSelectable *extension;
const gchar *color_spec;
const gchar *extension_name;
const gchar *uid;
gint i, first_empty = 0;
static AssignedColorData assigned_colors[] = {
{ "#BECEDD", NULL }, /* 190 206 221 Blue */
{ "#E2F0EF", NULL }, /* 226 240 239 Light Blue */
{ "#C6E2B7", NULL }, /* 198 226 183 Green */
{ "#E2F0D3", NULL }, /* 226 240 211 Light Green */
{ "#E2D4B7", NULL }, /* 226 212 183 Khaki */
{ "#EAEAC1", NULL }, /* 234 234 193 Light Khaki */
{ "#F0B8B7", NULL }, /* 240 184 183 Pink */
{ "#FED4D3", NULL }, /* 254 212 211 Light Pink */
{ "#E2C6E1", NULL }, /* 226 198 225 Purple */
{ "#F0E2EF", NULL } /* 240 226 239 Light Purple */
};
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
switch (e_cal_client_get_source_type (comp_data->client)) {
case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
break;
case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
break;
case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
extension_name = E_SOURCE_EXTENSION_MEMO_LIST;
break;
default:
g_return_val_if_reached (NULL);
}
source = e_client_get_source (E_CLIENT (comp_data->client));
extension = e_source_get_extension (source, extension_name);
color_spec = e_source_selectable_get_color (extension);
if (color_spec != NULL) {
g_free (comp_data->color);
comp_data->color = g_strdup (color_spec);
return comp_data->color;
}
uid = e_source_get_uid (source);
for (i = 0; i < G_N_ELEMENTS (assigned_colors); i++) {
GList *l;
if (assigned_colors[i].uids == NULL) {
first_empty = i;
continue;
}
for (l = assigned_colors[i].uids; l != NULL; l = l->next)
if (g_strcmp0 (l->data, uid) == 0)
return assigned_colors[i].color;
}
/* return the first unused color */
assigned_colors[first_empty].uids = g_list_append (
assigned_colors[first_empty].uids, g_strdup (uid));
return assigned_colors[first_empty].color;
}
gboolean
e_cal_model_get_confirm_delete (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE);
return model->priv->confirm_delete;
}
void
e_cal_model_set_confirm_delete (ECalModel *model,
gboolean confirm_delete)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if ((model->priv->confirm_delete ? 1 : 0) == (confirm_delete ? 1 : 0))
return;
model->priv->confirm_delete = confirm_delete;
g_object_notify (G_OBJECT (model), "confirm-delete");
}
icalcomponent_kind
e_cal_model_get_component_kind (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), ICAL_NO_COMPONENT);
return model->priv->kind;
}
void
e_cal_model_set_component_kind (ECalModel *model,
icalcomponent_kind kind)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
model->priv->kind = kind;
}
ECalModelFlags
e_cal_model_get_flags (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->flags;
}
void
e_cal_model_set_flags (ECalModel *model,
ECalModelFlags flags)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
model->priv->flags = flags;
}
ESourceRegistry *
e_cal_model_get_registry (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
return model->priv->registry;
}
icaltimezone *
e_cal_model_get_timezone (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
return model->priv->zone;
}
void
e_cal_model_set_timezone (ECalModel *model,
icaltimezone *zone)
{
icaltimezone *old_zone;
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->zone == zone)
return;
e_table_model_pre_change (E_TABLE_MODEL (model));
old_zone = model->priv->zone;
model->priv->zone = zone;
/* the timezone affects the times shown for date fields,
* so we need to redisplay everything */
e_table_model_changed (E_TABLE_MODEL (model));
redo_queries (model);
g_object_notify (G_OBJECT (model), "timezone");
g_signal_emit (G_OBJECT (model), signals[TIMEZONE_CHANGED], 0,
old_zone, zone);
}
gboolean
e_cal_model_get_compress_weekend (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE);
return model->priv->compress_weekend;
}
void
e_cal_model_set_compress_weekend (ECalModel *model,
gboolean compress_weekend)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if ((model->priv->compress_weekend ? 1 : 0) == (compress_weekend ? 1 : 0))
return;
model->priv->compress_weekend = compress_weekend;
g_object_notify (G_OBJECT (model), "compress-weekend");
}
void
e_cal_model_set_default_category (ECalModel *model,
const gchar *default_category)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
g_free (model->priv->default_category);
model->priv->default_category = g_strdup (default_category);
}
gint
e_cal_model_get_default_reminder_interval (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->default_reminder_interval;
}
void
e_cal_model_set_default_reminder_interval (ECalModel *model,
gint default_reminder_interval)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->default_reminder_interval == default_reminder_interval)
return;
model->priv->default_reminder_interval = default_reminder_interval;
g_object_notify (G_OBJECT (model), "default-reminder-interval");
}
EDurationType
e_cal_model_get_default_reminder_units (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->default_reminder_units;
}
void
e_cal_model_set_default_reminder_units (ECalModel *model,
EDurationType default_reminder_units)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->default_reminder_units == default_reminder_units)
return;
model->priv->default_reminder_units = default_reminder_units;
g_object_notify (G_OBJECT (model), "default-reminder-units");
}
gboolean
e_cal_model_get_use_24_hour_format (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE);
return model->priv->use_24_hour_format;
}
void
e_cal_model_set_use_24_hour_format (ECalModel *model,
gboolean use_24_hour_format)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->use_24_hour_format == use_24_hour_format)
return;
e_table_model_pre_change (E_TABLE_MODEL (model));
model->priv->use_24_hour_format = use_24_hour_format;
/* Get the views to redraw themselves. */
e_table_model_changed (E_TABLE_MODEL (model));
g_object_notify (G_OBJECT (model), "use-24-hour-format");
}
gboolean
e_cal_model_get_use_default_reminder (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), FALSE);
return model->priv->use_default_reminder;
}
void
e_cal_model_set_use_default_reminder (ECalModel *model,
gboolean use_default_reminder)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if ((model->priv->use_default_reminder ? 1 : 0) == (use_default_reminder ? 1 : 0))
return;
model->priv->use_default_reminder = use_default_reminder;
g_object_notify (G_OBJECT (model), "use-default-reminder");
}
gint
e_cal_model_get_week_start_day (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->week_start_day;
}
void
e_cal_model_set_week_start_day (ECalModel *model,
gint week_start_day)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
g_return_if_fail (week_start_day >= 0);
g_return_if_fail (week_start_day < 7);
if (model->priv->week_start_day == week_start_day)
return;
model->priv->week_start_day = week_start_day;
g_object_notify (G_OBJECT (model), "week-start-day");
}
gint
e_cal_model_get_work_day_end_hour (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->work_day_end_hour;
}
void
e_cal_model_set_work_day_end_hour (ECalModel *model,
gint work_day_end_hour)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->work_day_end_hour == work_day_end_hour)
return;
model->priv->work_day_end_hour = work_day_end_hour;
g_object_notify (G_OBJECT (model), "work-day-end-hour");
}
gint
e_cal_model_get_work_day_end_minute (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->work_day_end_minute;
}
void
e_cal_model_set_work_day_end_minute (ECalModel *model,
gint work_day_end_minute)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->work_day_end_minute == work_day_end_minute)
return;
model->priv->work_day_end_minute = work_day_end_minute;
g_object_notify (G_OBJECT (model), "work-day-end-minute");
}
gint
e_cal_model_get_work_day_start_hour (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->work_day_start_hour;
}
void
e_cal_model_set_work_day_start_hour (ECalModel *model,
gint work_day_start_hour)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->work_day_start_hour == work_day_start_hour)
return;
model->priv->work_day_start_hour = work_day_start_hour;
g_object_notify (G_OBJECT (model), "work-day-start-hour");
}
gint
e_cal_model_get_work_day_start_minute (ECalModel *model)
{
g_return_val_if_fail (E_IS_CAL_MODEL (model), 0);
return model->priv->work_day_start_minute;
}
void
e_cal_model_set_work_day_start_minute (ECalModel *model,
gint work_day_start_minute)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
if (model->priv->work_day_start_minute == work_day_start_minute)
return;
model->priv->work_day_start_minute = work_day_start_minute;
g_object_notify (G_OBJECT (model), "work-day-start-minute");
}
ECalClient *
e_cal_model_get_default_client (ECalModel *model)
{
ECalModelPrivate *priv;
ECalModelClient *client_data;
g_return_val_if_fail (model != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
/* FIXME Should we force the client to be open? */
/* we always return a valid ECal, since we rely on it in many places */
if (priv->default_client)
return priv->default_client;
if (!priv->clients)
return NULL;
client_data = (ECalModelClient *) priv->clients->data;
return client_data ? client_data->client : NULL;
}
void
e_cal_model_set_default_client (ECalModel *model,
ECalClient *client)
{
ECalModelPrivate *priv;
ECalModelClient *client_data;
g_return_if_fail (E_IS_CAL_MODEL (model));
if (client != NULL)
g_return_if_fail (E_IS_CAL_CLIENT (client));
priv = model->priv;
if (priv->default_client == client)
return;
if (priv->default_client) {
client_data = find_client_data (model, priv->default_client);
if (!client_data) {
g_warning ("client_data is NULL\n");
} else {
if (!client_data->do_query)
remove_client (model, client_data);
}
}
if (client != NULL) {
/* Make sure its in the model */
client_data = add_new_client (model, client, FALSE);
/* Store the default client */
priv->default_client = client_data->client;
} else
priv->default_client = NULL;
g_object_notify (G_OBJECT (model), "default-client");
}
GList *
e_cal_model_get_client_list (ECalModel *model)
{
GList *list = NULL, *l;
ECalClient *default_client;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
default_client = model->priv->default_client;
for (l = model->priv->clients; l != NULL; l = l->next) {
ECalModelClient *client_data = (ECalModelClient *) l->data;
/* Exclude the default client if we're not querying it. */
if (client_data->client == default_client && !client_data->do_query)
continue;
list = g_list_append (list, client_data->client);
}
return list;
}
/**
* e_cal_model_get_client_for_source:
* @model: an #ECalModel
* @source: an #ESource
*/
ECalClient *
e_cal_model_get_client_for_source (ECalModel *model,
ESource *source)
{
GList *link;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
g_return_val_if_fail (E_IS_SOURCE (source), NULL);
for (link = model->priv->clients; link != NULL; link = link->next) {
ECalModelClient *client_data;
ESource *client_source;
EClient *client;
client_data = (ECalModelClient *) link->data;
client = E_CLIENT (client_data->client);
client_source = e_client_get_source (client);
if (e_source_equal (source, client_source))
return client_data->client;
}
return NULL;
}
static ECalModelClient *
find_client_data (ECalModel *model,
ECalClient *client)
{
ECalModelPrivate *priv;
GList *l;
priv = model->priv;
for (l = priv->clients; l != NULL; l = l->next) {
ECalModelClient *client_data = (ECalModelClient *) l->data;
if (client_data->client == client)
return client_data;
}
return NULL;
}
static ECalModelComponent *
search_by_id_and_client (ECalModelPrivate *priv,
ECalClient *client,
const ECalComponentId *id)
{
gint i;
for (i = 0; i < priv->objects->len; i++) {
ECalModelComponent *comp_data = g_ptr_array_index (priv->objects, i);
if (comp_data) {
const gchar *uid;
gchar *rid = NULL;
struct icaltimetype icalrid;
gboolean has_rid = (id->rid && *id->rid);
uid = icalcomponent_get_uid (comp_data->icalcomp);
icalrid = icalcomponent_get_recurrenceid (comp_data->icalcomp);
if (!icaltime_is_null_time (icalrid))
rid = icaltime_as_ical_string_r (icalrid);
if (uid && *uid) {
if ((!client || comp_data->client == client) && !strcmp (id->uid, uid)) {
if (has_rid) {
if (!(rid && *rid && !strcmp (rid, id->rid))) {
g_free (rid);
continue;
}
}
g_free (rid);
return comp_data;
}
}
g_free (rid);
}
}
return NULL;
}
static void
remove_all_for_id_and_client (ECalModel *model,
ECalClient *client,
const ECalComponentId *id)
{
ECalModelComponent *comp_data;
while ((comp_data = search_by_id_and_client (model->priv, client, id))) {
gint pos;
GSList *list = NULL;
pos = get_position_in_array (model->priv->objects, comp_data);
if (!g_ptr_array_remove (model->priv->objects, comp_data))
continue;
list = g_slist_append (list, comp_data);
g_signal_emit (G_OBJECT (model), signals[COMPS_DELETED], 0, list);
g_slist_free (list);
g_object_unref (comp_data);
e_table_model_pre_change (E_TABLE_MODEL (model));
e_table_model_row_deleted (E_TABLE_MODEL (model), pos);
}
}
typedef struct {
ECalClient *client;
ECalClientView *view;
ECalModel *model;
icalcomponent *icalcomp;
} RecurrenceExpansionData;
static void
free_rdata (gpointer data)
{
RecurrenceExpansionData *rdata = data;
if (!rdata)
return;
g_object_unref (rdata->client);
g_object_unref (rdata->view);
g_object_unref (rdata->model);
g_free (rdata);
}
static gboolean
add_instance_cb (ECalComponent *comp,
time_t instance_start,
time_t instance_end,
gpointer user_data)
{
ECalModelComponent *comp_data;
ECalModelPrivate *priv;
RecurrenceExpansionData *rdata = user_data;
icaltimetype time;
ECalComponentDateTime datetime, to_set;
icaltimezone *zone = NULL;
ECalComponentId *id;
g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), TRUE);
priv = rdata->model->priv;
id = e_cal_component_get_id (comp);
remove_all_for_id_and_client (rdata->model, rdata->client, id);
e_cal_component_free_id (id);
e_table_model_pre_change (E_TABLE_MODEL (rdata->model));
/* set the right instance start date to component */
e_cal_component_get_dtstart (comp, &datetime);
if (datetime.tzid)
e_cal_client_get_timezone_sync (rdata->client, datetime.tzid, &zone, NULL, NULL);
time = icaltime_from_timet_with_zone (instance_start, FALSE, zone ? zone : priv->zone);
to_set.value = &time;
to_set.tzid = datetime.tzid;
e_cal_component_set_dtstart (comp, &to_set);
e_cal_component_free_datetime (&datetime);
/* set the right instance end date to component*/
e_cal_component_get_dtend (comp, &datetime);
zone = NULL;
if (datetime.tzid)
e_cal_client_get_timezone_sync (rdata->client, datetime.tzid, &zone, NULL, NULL);
time = icaltime_from_timet_with_zone (instance_end, FALSE, zone ? zone : priv->zone);
to_set.value = &time;
to_set.tzid = datetime.tzid;
e_cal_component_set_dtend (comp, &to_set);
e_cal_component_free_datetime (&datetime);
comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL);
comp_data->client = g_object_ref (rdata->client);
comp_data->icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp));
comp_data->instance_start = instance_start;
comp_data->instance_end = instance_end;
g_ptr_array_add (priv->objects, comp_data);
e_table_model_row_inserted (E_TABLE_MODEL (rdata->model), priv->objects->len - 1);
return TRUE;
}
/* We do this check since the calendar items are downloaded from the server
* in the open_method, since the default timezone might not be set there. */
static void
ensure_dates_are_in_default_zone (ECalModel *model,
icalcomponent *icalcomp)
{
icaltimetype dt;
icaltimezone *zone;
zone = e_cal_model_get_timezone (model);
if (!zone)
return;
dt = icalcomponent_get_dtstart (icalcomp);
if (dt.is_utc) {
dt = icaltime_convert_to_zone (dt, zone);
icalcomponent_set_dtstart (icalcomp, dt);
}
dt = icalcomponent_get_dtend (icalcomp);
if (dt.is_utc) {
dt = icaltime_convert_to_zone (dt, zone);
icalcomponent_set_dtend (icalcomp, dt);
}
}
static gint
place_master_object_first_cb (gconstpointer p1,
gconstpointer p2)
{
icalcomponent *c1 = (icalcomponent *) p1, *c2 = (icalcomponent *) p2;
const gchar *uid1, *uid2;
gint res;
g_return_val_if_fail (c1 != NULL, 0);
g_return_val_if_fail (c2 != NULL, 0);
uid1 = icalcomponent_get_uid (c1);
uid2 = icalcomponent_get_uid (c2);
res = g_strcmp0 (uid1, uid2);
if (res == 0) {
struct icaltimetype rid1, rid2;
rid1 = icalcomponent_get_recurrenceid (c1);
rid2 = icalcomponent_get_recurrenceid (c2);
if (icaltime_is_null_time (rid1)) {
if (!icaltime_is_null_time (rid2))
res = -1;
} else if (icaltime_is_null_time (rid2)) {
res = 1;
} else {
res = icaltime_compare (rid1, rid2);
}
}
return res;
}
static void client_view_objects_added_cb (ECalClientView *view, const GSList *objects, ECalModel *model);
static void
process_added (ECalClientView *view,
const GSList *objects,
ECalModel *model)
{
ECalModelPrivate *priv;
const GSList *l;
GSList *copy;
priv = model->priv;
/* order matters, process master object first, then detached instances */
copy = g_slist_sort (g_slist_copy ((GSList *) objects), place_master_object_first_cb);
for (l = copy; l; l = l->next) {
ECalModelComponent *comp_data;
ECalComponentId *id;
ECalComponent *comp = e_cal_component_new ();
ECalClient *client = e_cal_client_view_get_client (view);
/* This will fail for alarm or VCalendar component */
if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (l->data))) {
g_object_unref (comp);
continue;
}
id = e_cal_component_get_id (comp);
/* remove the components if they are already present and re-add them */
remove_all_for_id_and_client (model, client, id);
e_cal_component_free_id (id);
g_object_unref (comp);
ensure_dates_are_in_default_zone (model, l->data);
if (e_cal_util_component_has_recurrences (l->data) && (priv->flags & E_CAL_MODEL_FLAGS_EXPAND_RECURRENCES)) {
ECalModelClient *client_data = find_client_data (model, client);
if (client_data) {
RecurrenceExpansionData *rdata = g_new0 (RecurrenceExpansionData, 1);
rdata->client = g_object_ref (client);
rdata->view = g_object_ref (view);
rdata->model = g_object_ref (model);
e_cal_client_generate_instances_for_object (rdata->client, l->data, priv->start, priv->end, client_data->cancellable,
(ECalRecurInstanceFn) add_instance_cb, rdata, free_rdata);
}
} else {
e_table_model_pre_change (E_TABLE_MODEL (model));
comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL);
comp_data->client = g_object_ref (client);
comp_data->icalcomp = icalcomponent_new_clone (l->data);
e_cal_model_set_instance_times (comp_data, priv->zone);
g_ptr_array_add (priv->objects, comp_data);
e_table_model_row_inserted (E_TABLE_MODEL (model), priv->objects->len - 1);
}
}
g_slist_free (copy);
}
static void
process_modified (ECalClientView *view,
const GSList *objects,
ECalModel *model)
{
ECalModelPrivate *priv;
const GSList *l;
GSList *list = NULL;
priv = model->priv;
/* re-add only the recurrence objects */
for (l = objects; l != NULL; l = g_slist_next (l)) {
if (!e_cal_util_component_is_instance (l->data) && e_cal_util_component_has_recurrences (l->data) && (priv->flags & E_CAL_MODEL_FLAGS_EXPAND_RECURRENCES))
list = g_slist_prepend (list, l->data);
else {
gint pos;
ECalModelComponent *comp_data;
ECalComponentId *id;
ECalComponent *comp = e_cal_component_new ();
ECalClient *client = e_cal_client_view_get_client (view);
if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (l->data))) {
g_object_unref (comp);
continue;
}
e_table_model_pre_change (E_TABLE_MODEL (model));
id = e_cal_component_get_id (comp);
comp_data = search_by_id_and_client (priv, client, id);
e_cal_component_free_id (id);
g_object_unref (comp);
if (!comp_data) {
/* the modified component is not in the model yet, just skip it */
continue;
}
if (comp_data->icalcomp)
icalcomponent_free (comp_data->icalcomp);
if (comp_data->dtstart) {
g_free (comp_data->dtstart);
comp_data->dtstart = NULL;
}
if (comp_data->dtend) {
g_free (comp_data->dtend);
comp_data->dtend = NULL;
}
if (comp_data->due) {
g_free (comp_data->due);
comp_data->due = NULL;
}
if (comp_data->completed) {
g_free (comp_data->completed);
comp_data->completed = NULL;
}
if (comp_data->created) {
g_free (comp_data->created);
comp_data->created = NULL;
}
if (comp_data->lastmodified) {
g_free (comp_data->lastmodified);
comp_data->lastmodified = NULL;
}
if (comp_data->color) {
g_free (comp_data->color);
comp_data->color = NULL;
}
comp_data->icalcomp = icalcomponent_new_clone (l->data);
e_cal_model_set_instance_times (comp_data, priv->zone);
pos = get_position_in_array (priv->objects, comp_data);
e_table_model_row_changed (E_TABLE_MODEL (model), pos);
}
}
client_view_objects_added_cb (view, list, model);
g_slist_free (list);
}
static void
process_removed (ECalClientView *view,
const GSList *ids,
ECalModel *model)
{
ECalModelPrivate *priv;
const GSList *l;
priv = model->priv;
for (l = ids; l; l = l->next) {
ECalModelComponent *comp_data = NULL;
ECalComponentId *id = l->data;
gint pos;
/* make sure we remove all objects with this UID */
while ((comp_data = search_by_id_and_client (priv, e_cal_client_view_get_client (view), id))) {
GSList *l = NULL;
pos = get_position_in_array (priv->objects, comp_data);
if (!g_ptr_array_remove (priv->objects, comp_data))
continue;
l = g_slist_append (l, comp_data);
g_signal_emit (G_OBJECT (model), signals[COMPS_DELETED], 0, l);
g_slist_free (l);
g_object_unref (comp_data);
e_table_model_pre_change (E_TABLE_MODEL (model));
e_table_model_row_deleted (E_TABLE_MODEL (model), pos);
}
}
/* to notify about changes, because in call of row_deleted there are still all events */
e_table_model_changed (E_TABLE_MODEL (model));
}
static gpointer
copy_comp_id (gpointer id)
{
ECalComponentId *comp_id = (ECalComponentId *) id, *copy;
g_return_val_if_fail (comp_id != NULL, NULL);
copy = g_new0 (ECalComponentId, 1);
copy->uid = g_strdup (comp_id->uid);
copy->rid = g_strdup (comp_id->rid);
return copy;
}
static void
free_comp_id (gpointer id)
{
ECalComponentId *comp_id = (ECalComponentId *) id;
g_return_if_fail (comp_id != NULL);
g_free (comp_id->uid);
g_free (comp_id->rid);
g_free (comp_id);
}
static void
process_event (ECalClientView *view,
const GSList *objects,
ECalModel *model,
void (*process_fn) (ECalClientView *view,
const GSList *objects,
ECalModel *model),
gboolean *in,
GHashTable *save_hash,
gpointer (*copy_fn) (gpointer data),
void (*free_fn) (gpointer data))
{
gboolean skip = FALSE;
const GSList *l;
g_return_if_fail (save_hash != NULL);
g_mutex_lock (&model->priv->notify_lock);
if (*in) {
GSList *save_list = g_hash_table_lookup (save_hash, view);
skip = TRUE;
for (l = objects; l; l = l->next) {
if (l->data)
save_list = g_slist_append (save_list, copy_fn (l->data));
}
g_hash_table_insert (save_hash, g_object_ref (view), save_list);
} else {
*in = TRUE;
}
g_mutex_unlock (&model->priv->notify_lock);
if (skip)
return;
/* do it */
process_fn (view, objects, model);
g_mutex_lock (&model->priv->notify_lock);
while (g_hash_table_size (save_hash)) {
gpointer key = NULL, value = NULL;
GHashTableIter iter;
GSList *save_list;
g_hash_table_iter_init (&iter, save_hash);
if (!g_hash_table_iter_next (&iter, &key, &value)) {
g_debug ("%s: Failed to get first item of the save_hash", G_STRFUNC);
break;
}
save_list = value;
view = g_object_ref (key);
g_hash_table_remove (save_hash, view);
g_mutex_unlock (&model->priv->notify_lock);
/* do it */
process_fn (view, save_list, model);
for (l = save_list; l; l = l->next) {
if (l->data) {
free_fn (l->data);
}
}
g_slist_free (save_list);
g_object_unref (view);
g_mutex_lock (&model->priv->notify_lock);
}
*in = FALSE;
g_mutex_unlock (&model->priv->notify_lock);
}
static void
client_view_objects_added_cb (ECalClientView *view,
const GSList *objects,
ECalModel *model)
{
process_event (
view, objects, model, process_added,
&model->priv->in_added,
model->priv->notify_added,
(gpointer (*)(gpointer)) icalcomponent_new_clone,
(void (*)(gpointer)) icalcomponent_free);
}
static void
client_view_objects_modified_cb (ECalClientView *view,
const GSList *objects,
ECalModel *model)
{
process_event (
view, objects, model, process_modified,
&model->priv->in_modified,
model->priv->notify_modified,
(gpointer (*)(gpointer)) icalcomponent_new_clone,
(void (*)(gpointer)) icalcomponent_free);
}
static void
client_view_objects_removed_cb (ECalClientView *view,
const GSList *ids,
ECalModel *model)
{
process_event (
view, ids, model, process_removed,
&model->priv->in_removed,
model->priv->notify_removed,
copy_comp_id, free_comp_id);
}
static void
client_view_progress_cb (ECalClientView *view,
gint percent,
const gchar *message,
gpointer user_data)
{
ECalModel *model = (ECalModel *) user_data;
ECalClient *client = e_cal_client_view_get_client (view);
g_return_if_fail (E_IS_CAL_MODEL (model));
g_signal_emit (
model, signals[CAL_VIEW_PROGRESS], 0, message,
percent, e_cal_client_get_source_type (client));
}
static void
client_view_complete_cb (ECalClientView *view,
const GError *error,
gpointer user_data)
{
ECalModel *model = (ECalModel *) user_data;
ECalClient *client = e_cal_client_view_get_client (view);
g_return_if_fail (E_IS_CAL_MODEL (model));
g_signal_emit (G_OBJECT (model), signals[CAL_VIEW_COMPLETE], 0, error,
e_cal_client_get_source_type (client));
}
struct get_view_data
{
ECalModel *model; /* do not touch this, if cancelled */
ECalModelClient *client_data; /* do not touch this, if cancelled */
GCancellable *cancellable;
guint tries;
};
static void
free_get_view_data (struct get_view_data *gvd)
{
if (!gvd)
return;
g_object_unref (gvd->cancellable);
g_free (gvd);
}
static gboolean retry_get_view_timeout_cb (gpointer user_data);
static void
get_view_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
struct get_view_data *gvd = user_data;
GError *error = NULL;
ECalClientView *view = NULL;
g_return_if_fail (source_object != NULL);
g_return_if_fail (result != NULL);
g_return_if_fail (gvd != NULL);
g_return_if_fail (gvd->model != NULL);
g_return_if_fail (gvd->client_data != NULL);
if (!e_cal_client_get_view_finish (E_CAL_CLIENT (source_object), result, &view, &error)) {
if (g_error_matches (error, E_CLIENT_ERROR, E_CLIENT_ERROR_CANCELLED) ||
g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_clear_error (&error);
free_get_view_data (gvd);
return;
}
if (gvd->tries < 10) {
g_clear_error (&error);
gvd->tries++;
g_timeout_add (500, retry_get_view_timeout_cb, gvd);
return;
}
g_debug ("%s: Failed to get view: %s", G_STRFUNC, error ? error->message : "Unknown error");
g_clear_error (&error);
} else {
gvd->client_data->view = view;
g_signal_connect (
gvd->client_data->view, "objects-added",
G_CALLBACK (client_view_objects_added_cb), gvd->model);
g_signal_connect (
gvd->client_data->view, "objects-modified",
G_CALLBACK (client_view_objects_modified_cb), gvd->model);
g_signal_connect (
gvd->client_data->view, "objects-removed",
G_CALLBACK (client_view_objects_removed_cb), gvd->model);
g_signal_connect (
gvd->client_data->view, "progress",
G_CALLBACK (client_view_progress_cb), gvd->model);
g_signal_connect (
gvd->client_data->view, "complete",
G_CALLBACK (client_view_complete_cb), gvd->model);
e_cal_client_view_start (gvd->client_data->view, &error);
if (error) {
g_debug ("%s: Failed to start view: %s", G_STRFUNC, error->message);
g_error_free (error);
}
}
free_get_view_data (gvd);
}
static gboolean
retry_get_view_timeout_cb (gpointer user_data)
{
struct get_view_data *gvd = user_data;
if (g_cancellable_is_cancelled (gvd->cancellable)) {
free_get_view_data (gvd);
return FALSE;
}
e_cal_client_get_view (gvd->client_data->client, gvd->model->priv->full_sexp, gvd->cancellable, get_view_cb, gvd);
return FALSE;
}
static void
update_e_cal_view_for_client (ECalModel *model,
ECalModelClient *client_data)
{
ECalModelPrivate *priv;
struct get_view_data *gvd;
priv = model->priv;
/* Skip if this client has not finished loading yet */
if (!e_client_is_opened (E_CLIENT (client_data->client)))
return;
/* free the previous view, if any */
if (client_data->view) {
g_signal_handlers_disconnect_matched (client_data->view, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, model);
g_object_unref (client_data->view);
client_data->view = NULL;
}
/* prepare the view */
g_return_if_fail (priv->full_sexp != NULL);
/* Don't create the new query if we won't use it */
if (!client_data->do_query)
return;
if (client_data->cancellable) {
g_cancellable_cancel (client_data->cancellable);
g_object_unref (client_data->cancellable);
}
client_data->cancellable = g_cancellable_new ();
gvd = g_new0 (struct get_view_data, 1);
gvd->client_data = client_data;
gvd->model = model;
gvd->tries = 0;
gvd->cancellable = g_object_ref (client_data->cancellable);
e_cal_client_get_view (client_data->client, priv->full_sexp, gvd->cancellable, get_view_cb, gvd);
}
void
e_cal_model_update_status_message (ECalModel *model,
const gchar *message,
gdouble percent)
{
g_return_if_fail (model != NULL);
g_signal_emit (model, signals[STATUS_MESSAGE], 0, message, percent);
}
static void
backend_died_cb (ECalClient *client,
gpointer user_data)
{
ECalModel *model;
model = E_CAL_MODEL (user_data);
e_cal_model_remove_client (model, client);
}
static void
cal_model_retrieve_capabilies_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ECalClient *client = E_CAL_CLIENT (source_object);
ECalModel *model = user_data;
ECalModelClient *client_data;
gchar *capabilities = NULL;
g_return_if_fail (client != NULL);
g_return_if_fail (model != NULL);
e_client_retrieve_capabilities_finish (
E_CLIENT (client), result, &capabilities, NULL);
g_free (capabilities);
e_cal_model_update_status_message (model, NULL, -1.0);
client_data = find_client_data (model, client);
g_return_if_fail (client_data);
update_e_cal_view_for_client (model, client_data);
}
struct RetryOpenData
{
EClient *client;
ECalModel *model;
GCancellable *cancellable;
};
static void
free_retry_open_data (gpointer data)
{
struct RetryOpenData *rod = data;
if (!rod)
return;
g_object_unref (rod->client);
g_object_unref (rod->cancellable);
g_free (rod);
}
static gboolean cal_model_retry_open_timeout_cb (gpointer user_data);
static void
client_opened_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
ECalClient *client = E_CAL_CLIENT (source_object);
ECalModel *model = (ECalModel *) user_data;
GError *error = NULL;
e_client_open_finish (E_CLIENT (client), result, &error);
if (g_error_matches (error, E_CLIENT_ERROR, E_CLIENT_ERROR_CANCELLED) ||
g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_error_free (error);
return;
}
if (error && g_error_matches (error, E_CLIENT_ERROR, E_CLIENT_ERROR_BUSY)) {
struct RetryOpenData *rod;
rod = g_new0 (struct RetryOpenData, 1);
rod->client = g_object_ref (client);
rod->model = model;
rod->cancellable = g_object_ref (model->priv->loading_clients);
/* postpone for 1/2 of a second, backend is busy now */
g_timeout_add_full (
G_PRIORITY_DEFAULT, 500,
cal_model_retry_open_timeout_cb,
rod, free_retry_open_data);
g_error_free (error);
return;
}
if (error != NULL) {
ESource *source;
source = e_client_get_source (E_CLIENT (client));
e_cal_model_remove_client (model, client);
g_warning (
"%s: Failed to open '%s': %s",
G_STRFUNC,
e_source_get_display_name (source),
error->message);
g_error_free (error);
e_cal_model_update_status_message (model, NULL, -1.0);
return;
}
/* to have them ready for later use */
e_client_retrieve_capabilities (
E_CLIENT (client), model->priv->loading_clients,
cal_model_retrieve_capabilies_cb, model);
}
static gboolean
cal_model_retry_open_timeout_cb (gpointer user_data)
{
struct RetryOpenData *rod = user_data;
g_return_val_if_fail (rod != NULL, FALSE);
g_return_val_if_fail (rod->client != NULL, FALSE);
g_return_val_if_fail (rod->model != NULL, FALSE);
e_client_open (
rod->client, TRUE, rod->cancellable,
client_opened_cb, rod->model);
return FALSE;
}
static ECalModelClient *
add_new_client (ECalModel *model,
ECalClient *client,
gboolean do_query)
{
ECalModelPrivate *priv;
ECalModelClient *client_data;
priv = model->priv;
/* DEBUG the load state should always be loaded here
if (e_cal_get_load_state (client) != E_CAL_LOAD_LOADED) {
g_assert_not_reached ();
} */
/* Look to see if we already have this client */
client_data = find_client_data (model, client);
if (client_data) {
if (client_data->do_query)
return client_data;
else
client_data->do_query = do_query;
goto load;
}
client_data = g_new0 (ECalModelClient, 1);
client_data->client = g_object_ref (client);
client_data->view = NULL;
client_data->do_query = do_query;
priv->clients = g_list_append (priv->clients, client_data);
g_signal_connect (
client_data->client, "backend_died",
G_CALLBACK (backend_died_cb), model);
load:
if (e_client_is_opened (E_CLIENT (client))) {
update_e_cal_view_for_client (model, client_data);
} else {
ESource *source;
const gchar *display_name;
gchar *msg;
source = e_client_get_source (E_CLIENT (client));
display_name = e_source_get_display_name (source);
msg = g_strdup_printf (_("Opening %s"), display_name);
e_cal_model_update_status_message (model, msg, -1.0);
g_free (msg);
e_cal_client_set_default_timezone (client, e_cal_model_get_timezone (model));
e_client_open (E_CLIENT (client), TRUE, model->priv->loading_clients, client_opened_cb, model);
}
return client_data;
}
/**
* e_cal_model_add_client
*/
void
e_cal_model_add_client (ECalModel *model,
ECalClient *client)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
g_return_if_fail (E_IS_CAL_CLIENT (client));
add_new_client (model, client, TRUE);
}
static void
remove_client_objects (ECalModel *model,
ECalModelClient *client_data)
{
gint i;
/* remove all objects belonging to this client */
for (i = model->priv->objects->len; i > 0; i--) {
ECalModelComponent *comp_data = (ECalModelComponent *) g_ptr_array_index (model->priv->objects, i - 1);
g_return_if_fail (comp_data != NULL);
if (comp_data->client == client_data->client) {
GSList *l = NULL;
g_ptr_array_remove (model->priv->objects, comp_data);
l = g_slist_append (l, comp_data);
g_signal_emit (G_OBJECT (model), signals[COMPS_DELETED], 0, l);
g_slist_free (l);
g_object_unref (comp_data);
e_table_model_pre_change (E_TABLE_MODEL (model));
e_table_model_row_deleted (E_TABLE_MODEL (model), i - 1);
}
}
/* to notify about changes, because in call of row_deleted there are still all events */
e_table_model_changed (E_TABLE_MODEL (model));
}
static void
remove_client (ECalModel *model,
ECalModelClient *client_data)
{
/* FIXME We might not want to disconnect the open signal for the default client */
g_signal_handlers_disconnect_matched (client_data->client, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, model);
if (client_data->view)
g_signal_handlers_disconnect_matched (client_data->view, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, model);
remove_client_objects (model, client_data);
/* If this is the default client and we were querying (so it
* was also a source), keep it around but don't query it */
if (model->priv->default_client == client_data->client && client_data->do_query) {
client_data->do_query = FALSE;
return;
}
if (model->priv->default_client == client_data->client)
model->priv->default_client = NULL;
/* Remove the client from the list */
model->priv->clients = g_list_remove (model->priv->clients, client_data);
/* free all remaining memory */
g_object_unref (client_data->client);
if (client_data->view)
g_object_unref (client_data->view);
g_free (client_data);
}
/**
* e_cal_model_remove_client
*/
void
e_cal_model_remove_client (ECalModel *model,
ECalClient *client)
{
ECalModelClient *client_data;
g_return_if_fail (E_IS_CAL_MODEL (model));
g_return_if_fail (E_IS_CAL_CLIENT (client));
client_data = find_client_data (model, client);
if (client_data)
remove_client (model, client_data);
}
/**
* e_cal_model_remove_all_clients
*/
void
e_cal_model_remove_all_clients (ECalModel *model)
{
ECalModelPrivate *priv;
g_return_if_fail (E_IS_CAL_MODEL (model));
priv = model->priv;
while (priv->clients != NULL) {
ECalModelClient *client_data = (ECalModelClient *) priv->clients->data;
remove_client (model, client_data);
}
}
static GSList *
get_objects_as_list (ECalModel *model)
{
gint i;
GSList *l = NULL;
ECalModelPrivate *priv = model->priv;
for (i = 0; i < priv->objects->len; i++) {
ECalModelComponent *comp_data;
comp_data = g_ptr_array_index (priv->objects, i);
if (comp_data == NULL) {
g_warning ("comp_data is null\n");
continue;
}
l = g_slist_prepend (l, comp_data);
}
return l;
}
struct cc_data
{
ECalModel *model;
EFlag *eflag;
};
static gboolean
cleanup_content_cb (gpointer user_data)
{
ECalModel *model;
ECalModelPrivate *priv;
GSList *slist;
gint len;
struct cc_data *data = user_data;
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (data->model != NULL, FALSE);
g_return_val_if_fail (data->eflag != NULL, FALSE);
model = data->model;
priv = model->priv;
g_return_val_if_fail (priv != NULL, FALSE);
e_table_model_pre_change (E_TABLE_MODEL (model));
len = priv->objects->len;
slist = get_objects_as_list (model);
g_ptr_array_set_size (priv->objects, 0);
g_signal_emit (G_OBJECT (model), signals[COMPS_DELETED], 0, slist);
e_table_model_rows_deleted (E_TABLE_MODEL (model), 0, len);
g_slist_foreach (slist, (GFunc) g_object_unref, NULL);
g_slist_free (slist);
e_flag_set (data->eflag);
return FALSE;
}
static void
redo_queries (ECalModel *model)
{
ECalModelPrivate *priv;
GList *l;
struct cc_data data;
priv = model->priv;
if (priv->full_sexp)
g_free (priv->full_sexp);
if (priv->start != -1 && priv->end != -1) {
gchar *iso_start, *iso_end;
const gchar *default_tzloc = NULL;
iso_start = isodate_from_time_t (priv->start);
iso_end = isodate_from_time_t (priv->end);
if (priv->zone && priv->zone != icaltimezone_get_utc_timezone ())
default_tzloc = icaltimezone_get_location (priv->zone);
if (!default_tzloc)
default_tzloc = "";
if (priv->search_sexp) {
priv->full_sexp = g_strdup_printf (
"(and (occur-in-time-range? (make-time \"%s\") (make-time \"%s\") \"%s\") %s)",
iso_start, iso_end, default_tzloc,
priv->search_sexp ? priv->search_sexp : "");
} else {
priv->full_sexp = g_strdup_printf ("(occur-in-time-range? (make-time \"%s\") (make-time \"%s\") \"%s\")",
iso_start, iso_end, default_tzloc);
}
g_free (iso_start);
g_free (iso_end);
} else if (priv->search_sexp) {
priv->full_sexp = g_strdup (priv->search_sexp);
} else {
priv->full_sexp = g_strdup ("#f");
}
/* clean up the current contents, which should be done
* always from the main thread, because of gtk calls during removal */
data.model = model;
data.eflag = e_flag_new ();
if (!g_main_context_is_owner (g_main_context_default ())) {
/* function called from other than main thread */
g_timeout_add (10, cleanup_content_cb, &data);
e_flag_wait (data.eflag);
} else {
cleanup_content_cb (&data);
}
e_flag_free (data.eflag);
/* update the view for all clients */
for (l = priv->clients; l != NULL; l = l->next) {
ECalModelClient *client_data;
client_data = (ECalModelClient *) l->data;
update_e_cal_view_for_client (model, client_data);
}
}
void
e_cal_model_get_time_range (ECalModel *model,
time_t *start,
time_t *end)
{
ECalModelPrivate *priv;
g_return_if_fail (model != NULL);
g_return_if_fail (E_IS_CAL_MODEL (model));
priv = model->priv;
if (start)
*start = priv->start;
if (end)
*end = priv->end;
}
void
e_cal_model_set_time_range (ECalModel *model,
time_t start,
time_t end)
{
ECalModelPrivate *priv;
g_return_if_fail (model != NULL);
g_return_if_fail (E_IS_CAL_MODEL (model));
g_return_if_fail (start >= 0 && end >= 0);
g_return_if_fail (start <= end);
priv = model->priv;
if (priv->start == start && priv->end == end)
return;
priv->start = start;
priv->end = end;
g_signal_emit (G_OBJECT (model), signals[TIME_RANGE_CHANGED], 0, start, end);
redo_queries (model);
}
const gchar *
e_cal_model_get_search_query (ECalModel *model)
{
ECalModelPrivate *priv;
g_return_val_if_fail (model != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
return priv->search_sexp;
}
/**
* e_cal_model_set_query
*/
void
e_cal_model_set_search_query (ECalModel *model,
const gchar *sexp)
{
ECalModelPrivate *priv;
g_return_if_fail (E_IS_CAL_MODEL (model));
priv = model->priv;
if (!strcmp (sexp ? sexp : "", priv->search_sexp ? priv->search_sexp : ""))
return;
if (priv->search_sexp)
g_free (priv->search_sexp);
if (!sexp || !*sexp)
priv->search_sexp = NULL;
else
priv->search_sexp = g_strdup (sexp);
redo_queries (model);
}
/**
* e_cal_model_set_query
*/
void
e_cal_model_set_search_query_with_time_range (ECalModel *model,
const gchar *sexp,
time_t start,
time_t end)
{
ECalModelPrivate *priv;
gboolean do_query = FALSE;
g_return_if_fail (E_IS_CAL_MODEL (model));
priv = model->priv;
if (strcmp (sexp ? sexp : "", priv->search_sexp ? priv->search_sexp : "")) {
if (priv->search_sexp)
g_free (priv->search_sexp);
if (!sexp || !*sexp)
priv->search_sexp = NULL;
else
priv->search_sexp = g_strdup (sexp);
do_query = TRUE;
}
if (!(priv->start == start && priv->end == end)) {
priv->start = start;
priv->end = end;
do_query = TRUE;
g_signal_emit (G_OBJECT (model), signals[TIME_RANGE_CHANGED], 0, start, end);
}
if (do_query)
redo_queries (model);
}
/**
* e_cal_model_create_component_with_defaults
*/
icalcomponent *
e_cal_model_create_component_with_defaults (ECalModel *model,
gboolean all_day)
{
ECalModelPrivate *priv;
ECalComponent *comp;
icalcomponent *icalcomp;
ECalClient *client;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
g_return_val_if_fail (priv->clients != NULL, NULL);
client = e_cal_model_get_default_client (model);
if (!client)
return icalcomponent_new (priv->kind);
switch (priv->kind) {
case ICAL_VEVENT_COMPONENT :
comp = cal_comp_event_new_with_defaults (
client, all_day,
e_cal_model_get_use_default_reminder (model),
e_cal_model_get_default_reminder_interval (model),
e_cal_model_get_default_reminder_units (model));
break;
case ICAL_VTODO_COMPONENT :
comp = cal_comp_task_new_with_defaults (client);
break;
case ICAL_VJOURNAL_COMPONENT :
comp = cal_comp_memo_new_with_defaults (client);
break;
default:
return NULL;
}
if (!comp)
return icalcomponent_new (priv->kind);
icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp));
g_object_unref (comp);
/* make sure the component has an UID */
if (!icalcomponent_get_uid (icalcomp)) {
gchar *uid;
uid = e_cal_component_gen_uid ();
icalcomponent_set_uid (icalcomp, uid);
g_free (uid);
}
return icalcomp;
}
/**
* Returns information about attendees in the component.
* If there are no attendees, the function returns NULL.
*
* The information is like "Status: Accepted: X Declined: Y ...".
*
* Free returned pointer with g_free.
**/
gchar *
e_cal_model_get_attendees_status_info (ECalModel *model,
ECalComponent *comp,
ECalClient *cal_client)
{
struct _values {
icalparameter_partstat status;
const gchar *caption;
gint count;
} values[] = {
{ ICAL_PARTSTAT_ACCEPTED, N_("Accepted"), 0 },
{ ICAL_PARTSTAT_DECLINED, N_("Declined"), 0 },
{ ICAL_PARTSTAT_TENTATIVE, N_("Tentative"), 0 },
{ ICAL_PARTSTAT_DELEGATED, N_("Delegated"), 0 },
{ ICAL_PARTSTAT_NEEDSACTION, N_("Needs action"), 0 },
{ ICAL_PARTSTAT_NONE, N_("Other"), 0 },
{ ICAL_PARTSTAT_X, NULL, -1 }
};
ESourceRegistry *registry;
GSList *attendees = NULL, *a;
gboolean have = FALSE;
gchar *res = NULL;
gint i;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
registry = e_cal_model_get_registry (model);
if (!comp || !e_cal_component_has_attendees (comp) ||
!itip_organizer_is_user_ex (registry, comp, cal_client, TRUE))
return NULL;
e_cal_component_get_attendee_list (comp, &attendees);
for (a = attendees; a; a = a->next) {
ECalComponentAttendee *att = a->data;
if (att && att->cutype == ICAL_CUTYPE_INDIVIDUAL &&
(att->role == ICAL_ROLE_CHAIR ||
att->role == ICAL_ROLE_REQPARTICIPANT ||
att->role == ICAL_ROLE_OPTPARTICIPANT)) {
have = TRUE;
for (i = 0; values[i].count != -1; i++) {
if (att->status == values[i].status || values[i].status == ICAL_PARTSTAT_NONE) {
values[i].count++;
break;
}
}
}
}
if (have) {
GString *str = g_string_new ("");
for (i = 0; values[i].count != -1; i++) {
if (values[i].count > 0) {
if (str->str && *str->str)
g_string_append (str, " ");
g_string_append_printf (str, "%s: %d", _(values[i].caption), values[i].count);
}
}
g_string_prepend (str, ": ");
/* To Translators: 'Status' here means the state of the attendees, the resulting string will be in a form:
* Status: Accepted: X Declined: Y ... */
g_string_prepend (str, _("Status"));
res = g_string_free (str, FALSE);
}
if (attendees)
e_cal_component_free_attendee_list (attendees);
return res;
}
/**
* e_cal_model_get_color_for_component
*/
const gchar *
e_cal_model_get_color_for_component (ECalModel *model,
ECalModelComponent *comp_data)
{
ECalModelClass *model_class;
const gchar *color = NULL;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
g_return_val_if_fail (comp_data != NULL, NULL);
model_class = (ECalModelClass *) G_OBJECT_GET_CLASS (model);
if (model_class->get_color_for_component != NULL)
color = model_class->get_color_for_component (model, comp_data);
if (!color)
color = ecm_get_color_for_component (model, comp_data);
return color;
}
/**
* e_cal_model_get_rgb_color_for_component
*/
gboolean
e_cal_model_get_rgb_color_for_component (ECalModel *model,
ECalModelComponent *comp_data,
gdouble *red,
gdouble *green,
gdouble *blue)
{
GdkColor gdk_color;
const gchar *color;
color = e_cal_model_get_color_for_component (model, comp_data);
if (color && gdk_color_parse (color, &gdk_color)) {
if (red)
*red = ((double) gdk_color.red)/0xffff;
if (green)
*green = ((double) gdk_color.green)/0xffff;
if (blue)
*blue = ((double) gdk_color.blue)/0xffff;
return TRUE;
}
return FALSE;
}
/**
* e_cal_model_get_component_at
*/
ECalModelComponent *
e_cal_model_get_component_at (ECalModel *model,
gint row)
{
ECalModelPrivate *priv;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
g_return_val_if_fail (row >= 0 && row < priv->objects->len, NULL);
return g_ptr_array_index (priv->objects, row);
}
ECalModelComponent *
e_cal_model_get_component_for_uid (ECalModel *model,
const ECalComponentId *id)
{
ECalModelPrivate *priv;
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
priv = model->priv;
return search_by_id_and_client (priv, NULL, id);
}
/**
* e_cal_model_date_value_to_string
*/
gchar *
e_cal_model_date_value_to_string (ECalModel *model,
gconstpointer value)
{
ECalModelPrivate *priv;
ECellDateEditValue *dv = (ECellDateEditValue *) value;
struct icaltimetype tt;
struct tm tmp_tm;
gchar buffer[64];
g_return_val_if_fail (E_IS_CAL_MODEL (model), g_strdup (""));
priv = model->priv;
if (!dv)
return g_strdup ("");
/* We currently convert all the dates to the current timezone. */
tt = dv->tt;
icaltimezone_convert_time (&tt, dv->zone, priv->zone);
tmp_tm.tm_year = tt.year - 1900;
tmp_tm.tm_mon = tt.month - 1;
tmp_tm.tm_mday = tt.day;
tmp_tm.tm_hour = tt.hour;
tmp_tm.tm_min = tt.minute;
tmp_tm.tm_sec = tt.second;
tmp_tm.tm_isdst = -1;
tmp_tm.tm_wday = time_day_of_week (tt.day, tt.month - 1, tt.year);
memset (buffer, 0, sizeof (buffer));
e_time_format_date_and_time (&tmp_tm, priv->use_24_hour_format,
TRUE, FALSE,
buffer, sizeof (buffer));
return g_strdup (buffer);
}
/* FIXME is it still needed ?
static ECellDateEditValue *
copy_ecdv (ECellDateEditValue *ecdv)
{
ECellDateEditValue *new_ecdv;
*
new_ecdv = g_new0 (ECellDateEditValue, 1);
new_ecdv->tt = ecdv ? ecdv->tt : icaltime_null_time ();
new_ecdv->zone = ecdv ? ecdv->zone : NULL;
*
return new_ecdv;
} */
static void e_cal_model_component_finalize (GObject *object);
/* Class initialization function for the calendar component object */
static void
e_cal_model_component_class_init (ECalModelComponentClass *class)
{
GObjectClass *object_class;
object_class = (GObjectClass *) class;
g_type_class_add_private (class, sizeof (ECalModelComponentPrivate));
object_class->finalize = e_cal_model_component_finalize;
}
static void
e_cal_model_component_finalize (GObject *object)
{
ECalModelComponent *comp_data = E_CAL_MODEL_COMPONENT (object);
if (comp_data->client) {
g_object_unref (comp_data->client);
comp_data->client = NULL;
}
if (comp_data->icalcomp) {
icalcomponent_free (comp_data->icalcomp);
comp_data->icalcomp = NULL;
}
if (comp_data->dtstart) {
g_free (comp_data->dtstart);
comp_data->dtstart = NULL;
}
if (comp_data->dtend) {
g_free (comp_data->dtend);
comp_data->dtend = NULL;
}
if (comp_data->due) {
g_free (comp_data->due);
comp_data->due = NULL;
}
if (comp_data->completed) {
g_free (comp_data->completed);
comp_data->completed = NULL;
}
if (comp_data->created) {
g_free (comp_data->created);
comp_data->created = NULL;
}
if (comp_data->lastmodified) {
g_free (comp_data->lastmodified);
comp_data->lastmodified = NULL;
}
if (comp_data->color) {
g_free (comp_data->color);
comp_data->color = NULL;
}
if (comp_data->priv->categories_str)
g_string_free (comp_data->priv->categories_str, TRUE);
comp_data->priv->categories_str = NULL;
/* Chain up to parent's finalize() method. */
G_OBJECT_CLASS (e_cal_model_component_parent_class)->finalize (object);
}
static void
e_cal_model_component_init (ECalModelComponent *comp)
{
comp->priv = E_CAL_MODEL_COMPONENT_GET_PRIVATE (comp);
}
/**
* e_cal_model_generate_instances_sync
*
* cb function is not called with cb_data, but with ECalModelGenerateInstancesData which contains cb_data
*/
void
e_cal_model_generate_instances_sync (ECalModel *model,
time_t start,
time_t end,
ECalRecurInstanceFn cb,
gpointer cb_data)
{
ECalModelGenerateInstancesData mdata;
gint i, n;
n = e_table_model_row_count (E_TABLE_MODEL (model));
for (i = 0; i < n; i++) {
ECalModelComponent *comp_data = e_cal_model_get_component_at (model, i);
mdata.comp_data = comp_data;
mdata.cb_data = cb_data;
if (comp_data->instance_start < end && comp_data->instance_end > start)
e_cal_client_generate_instances_for_object_sync (comp_data->client, comp_data->icalcomp, start, end, cb, &mdata);
}
}
/**
* e_cal_model_get_object_array
*/
GPtrArray *
e_cal_model_get_object_array (ECalModel *model)
{
g_return_val_if_fail (model != NULL, NULL);
g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);
g_return_val_if_fail (model->priv != NULL, NULL);
return model->priv->objects;
}
void
e_cal_model_set_instance_times (ECalModelComponent *comp_data,
const icaltimezone *zone)
{
struct icaltimetype start_time, end_time;
icalcomponent_kind kind;
kind = icalcomponent_isa (comp_data->icalcomp);
start_time = icalcomponent_get_dtstart (comp_data->icalcomp);
end_time = icalcomponent_get_dtend (comp_data->icalcomp);
if (kind == ICAL_VEVENT_COMPONENT) {
if (start_time.is_date && icaltime_is_null_time (end_time)) {
/* If end_time is null and it's an all day event,
* just make start_time = end_time so that end_time
* will be a valid date
*/
end_time = start_time;
icaltime_adjust (&end_time, 1, 0, 0, 0);
icalcomponent_set_dtend (comp_data->icalcomp, end_time);
} else if (start_time.is_date && end_time.is_date &&
(icaltime_compare_date_only (start_time, end_time) == 0)) {
/* If both DTSTART and DTEND are DATE values, and they are the
* same day, we add 1 day to DTEND. This means that most
* events created with the old Evolution behavior will still
* work OK. */
icaltime_adjust (&end_time, 1, 0, 0, 0);
icalcomponent_set_dtend (comp_data->icalcomp, end_time);
}
}
if (start_time.zone)
zone = start_time.zone;
else {
icalparameter *param = NULL;
icalproperty *prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY);
if (prop) {
param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
if (param) {
const gchar *tzid = NULL;
icaltimezone *st_zone = NULL;
tzid = icalparameter_get_tzid (param);
if (tzid)
e_cal_client_get_timezone_sync (comp_data->client, tzid, &st_zone, NULL, NULL);
if (st_zone)
zone = st_zone;
}
}
}
comp_data->instance_start = icaltime_as_timet_with_zone (start_time, zone);
if (end_time.zone)
zone = end_time.zone;
else {
icalparameter *param = NULL;
icalproperty *prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_DTSTART_PROPERTY);
if (prop) {
param = icalproperty_get_first_parameter (prop, ICAL_TZID_PARAMETER);
if (param) {
const gchar *tzid = NULL;
icaltimezone *end_zone = NULL;
tzid = icalparameter_get_tzid (param);
if (tzid)
e_cal_client_get_timezone_sync (comp_data->client, tzid, &end_zone, NULL, NULL);
if (end_zone)
zone = end_zone;
}
}
}
comp_data->instance_end = icaltime_as_timet_with_zone (end_time, zone);
}
/**
* e_cal_model_set_default_time_func:
* This function will be used when creating new item from the "click-to-add",
* when user didn't fill a start date there.
**/
void
e_cal_model_set_default_time_func (ECalModel *model,
ECalModelDefaultTimeFunc func,
gpointer user_data)
{
g_return_if_fail (E_IS_CAL_MODEL (model));
model->priv->get_default_time = func;
model->priv->get_default_time_user_data = user_data;
}