From e7deedccdac5baf62f0adfd3a8cfb311157da01f Mon Sep 17 00:00:00 2001 From: Federico Mena Quintero Date: Tue, 13 Jun 2000 07:38:47 +0000 Subject: Added the array of objects and the hash table of UID->array index. 2000-06-13 Federico Mena Quintero * gui/calendar-model.c (CalendarModelPrivate): Added the array of objects and the hash table of UID->array index. (calendar_model_row_count): Return the length directly from the array instead of asking the Wombat. (calendar_model_value_at): Implemented. (calendar_model_new): Create an empty model. We provide a new setter function now. (calendar_model_construct): Removed function. (calendar_model_set_cal_client): New function to set the calendar client and object type at any time. This lets us reuse a calendar model object. * cal-util/calobj.h (iCalObjectField): Just report whether the object has alarms; not every single alarm. svn path=/trunk/; revision=3547 --- calendar/ChangeLog | 17 ++ calendar/cal-util/calobj.h | 5 +- calendar/gui/calendar-model.c | 482 ++++++++++++++++++++++++++++++++++++++++++ calendar/gui/calendar-model.h | 64 ++++++ 4 files changed, 564 insertions(+), 4 deletions(-) create mode 100644 calendar/gui/calendar-model.c create mode 100644 calendar/gui/calendar-model.h (limited to 'calendar') diff --git a/calendar/ChangeLog b/calendar/ChangeLog index 62233a4eb9..6ba8ac019e 100644 --- a/calendar/ChangeLog +++ b/calendar/ChangeLog @@ -1,3 +1,20 @@ +2000-06-13 Federico Mena Quintero + + * gui/calendar-model.c (CalendarModelPrivate): Added the array of + objects and the hash table of UID->array index. + (calendar_model_row_count): Return the length directly from the + array instead of asking the Wombat. + (calendar_model_value_at): Implemented. + (calendar_model_new): Create an empty model. We provide a new + setter function now. + (calendar_model_construct): Removed function. + (calendar_model_set_cal_client): New function to set the calendar + client and object type at any time. This lets us reuse a calendar + model object. + + * cal-util/calobj.h (iCalObjectField): Just report whether the + object has alarms; not every single alarm. + 2000-06-13 Ettore Perazzoli * gui/Makefile.am (SHELL_OBJS): Removed. diff --git a/calendar/cal-util/calobj.h b/calendar/cal-util/calobj.h index c93c79f906..bb0840fb67 100644 --- a/calendar/cal-util/calobj.h +++ b/calendar/cal-util/calobj.h @@ -45,10 +45,7 @@ typedef enum { ICAL_OBJECT_FIELD_PRIORITY, ICAL_OBJECT_FIELD_SUMMARY, ICAL_OBJECT_FIELD_URL, - ICAL_OBJECT_FIELD_DALARM, - ICAL_OBJECT_FIELD_AALARM, - ICAL_OBJECT_FIELD_PALARM, - ICAL_OBJECT_FIELD_MALARM, + ICAL_OBJECT_FIELD_HAS_ALARMS, /* not a real field */ ICAL_OBJECT_FIELD_NUM_FIELDS } iCalObjectField; diff --git a/calendar/gui/calendar-model.c b/calendar/gui/calendar-model.c new file mode 100644 index 0000000000..6562f225e1 --- /dev/null +++ b/calendar/gui/calendar-model.c @@ -0,0 +1,482 @@ +/* Evolution calendar - Data model for ETable + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Authors: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include "calendar-model.h" + + + +/* Private part of the ECalendarModel structure */ +typedef struct { + /* Calendar client we are using */ + CalClient *client; + + /* Types of objects we are dealing with */ + CalObjType type; + + /* Array of calendar objects */ + GPtrArray *objects; + + /* UID -> array index hash */ + GHashTable *uid_index_hash; +} CalendarModelPrivate; + + + +static void calendar_model_class_init (CalendarModelClass *class); +static void calendar_model_init (CalendarModel *model); +static void calendar_model_destroy (GtkObject *object); + +static int calendar_model_column_count (ETableModel *etm); +static int calendar_model_row_count (ETableModel *etm); +static void *calendar_model_value_at (ETableModel *etm, int col, int row); +static void calendar_model_set_value_at (ETableModel *etm, int col, int row, const void *value); +static gboolean calendar_model_is_cell_editable (ETableModel *etm, int col, int row); +static void *calendar_model_duplicate_value (ETableModel *etm, int col, const void *value); +static void calendar_model_free_value (ETableModel *etm, int col, void *value); +static void *calendar_model_initialize_value (ETableModel *etm, int col); +static gboolean calendar_model_value_is_empty (ETableModel *etm, int col, const void *value); + +static void calendar_model_freeze (ETableModel *etm); +static void calendar_model_thaw (ETableModel *etm); + +static ETableModelClass *parent_class; + + + +/** + * calendar_model_get_type: + * @void: + * + * Registers the #CalendarModel class if necessary, and returns the type ID + * associated to it. + * + * Return value: The type ID of the #CalendarModel class. + **/ +GtkType +calendar_model_get_type (void) +{ + static GtkType calendar_model_type = 0; + + if (!calendar_model_type) { + static GtkTypeInfo calendar_model_info = { + "CalendarModel", + sizeof (CalendarModel), + sizeof (CalendarModelClass), + (GtkClassInitFunc) calendar_model_class_init, + (GtkObjectInitFunc) calendar_model_init, + NULL, /* reserved_1 */ + NULL, /* reserved_2 */ + (GtkClassInitFunc) NULL + }; + + calendar_model_type = gtk_type_unique (E_TABLE_MODEL_TYPE, &calendar_model_info); + } + + return calendar_model_type; +} + +/* Class initialization function for the calendar table model */ +static void +calendar_model_class_init (CalendarModelClass *class) +{ + GtkObjectClass *object_class; + ETableModelClass *etm_class; + + object_class = (GtkObjectClass *) class; + etm_class = (ETableModelClass *) class; + + parent_class = gtk_type_class (E_TABLE_MODEL_TYPE); + + object_class->destroy = calendar_model_destroy; +} + +/* Object initialization function for the calendar table model */ +static void +calendar_model_init (CalendarModel *model) +{ + CalendarModelPrivate *priv; + + priv = g_new0 (CalendarModelPrivate, 1); + model->priv = priv; + + priv->objects = g_ptr_array_new (); + priv->uid_index_hash = g_hash_table_new (g_str_hash, g_str_equal); +} + +/* Called from g_hash_table_foreach_remove(), frees a stored UID->index + * mapping. + */ +static gboolean +free_uid_index (gpointer key, gpointer value, gpointer data) +{ + int *idx; + + idx = value; + g_free (idx); + + return TRUE; +} + +/* Frees the objects stored in the calendar model */ +static void +free_objects (CalendarModel *model) +{ + CalendarModelPrivate *priv; + int i; + + priv = model->data; + + g_hash_table_foreach_remove (priv->objects, free_uid_index, NULL); + + for (i = 0; i < priv->objects->len; i++) { + iCalObject *ico; + + ico = g_ptr_array_index (priv->objects, i); + g_assert (ico != NULL); + ical_object_unref (ico); + } + + g_ptr_array_set_size (priv->objects, 0); +} + +/* Destroy handler for the calendar table model */ +static void +calendar_model_destroy (GtkObject *object) +{ + CalendarModel *model; + CalendarModelPrivate *priv; + int i; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_CALENDAR_MODEL (object)); + + model = CALENDAR_MODEL (object); + priv = model->priv; + + /* Free the calendar client interface object */ + + if (priv->client) { + gtk_object_unref (GTK_OBJECT (priv->client)); + priv->client = NULL; + } + + /* Free the uid->index hash data and the array of UIDs */ + + free_objects (model); + + g_hash_table_destroy (priv->uid_index_hash); + priv->uid_index_hash = NULL; + + g_ptr_array_free (priv->objects, TRUE); + priv->objects = NULL; + + /* Free the private structure */ + + g_free (priv); + model->priv = NULL; + + if (GTK_OBJECT_CLASS (parent_class)->destroy) + (* GTK_OBJECT_CLASS (parent_class)->destroy) (object); +} + + + +/* ETableModel methods */ + +/* column_count handler for the calendar table model */ +static int +calendar_model_column_count (ETableModel *etm) +{ + return ICAL_OBJECT_FIELD_NUM_FIELDS; +} + +/* row_count handler for the calendar table model */ +static int +calendar_model_row_count (ETableModel *etm) +{ + CalendarModel *model; + CalendarModelPrivate *priv; + + model = CALENDAR_MODEL (etm); + priv = model->priv; + + return priv->objects->len; +} + +/* value_at handler for the calendar table model */ +static void * +calendar_model_value_at (ETableModel *etm, int col, int row) +{ + CalendarModel *model; + CalendarModelPrivate *priv; + iCalObject *ico; + void *retval; + + model = CALENDAR_MODEL (etm); + priv = model->priv; + + if (row >= priv->objects->len) { + g_message ("calendar_model_value_at(): Requested invalid row index %d", row); + return NULL; + } + + ico = g_ptr_array_index (priv->objects, row); + g_assert (ico != NULL); + + switch (col) { + case ICAL_OBJECT_FIELD_COMMENT: + return ico->comment ? ico->commment : ""; + + case ICAL_OBJECT_FIELD_COMPLETED: + return &ico->completed; + + case ICAL_OBJECT_FIELD_CREATED: + return &ico->created; + + case ICAL_OBJECT_FIELD_DESCRIPTION: + return ico->desc ? ico->desc : ""; + + case ICAL_OBJECT_FIELD_DTSTAMP: + return &ico->dtstamp; + + case ICAL_OBJECT_FIELD_DTSTART: + return &ico->dtstart; + + case ICAL_OBJECT_FIELD_DTEND: + return &ico->dtend; + + case ICAL_OBJECT_FIELD_GEO: + return &ico->geo; + + case ICAL_OBJECT_FIELD_LAST_MOD: + return &ico->last_mod; + + case ICAL_OBJECT_FIELD_LOCATION: + return ico->location ? ico->location : ""; + + case ICAL_OBJECT_FIELD_ORGANIZER: + return ico->organizer; + + case ICAL_OBJECT_FIELD_PERCENT: + return &ico->percent; + + case ICAL_OBJECT_FIELD_PRIORITY: + return &ico->priority; + + case ICAL_OBJECT_FIELD_SUMMARY: + return ico->summary ? ico->summary : ""; + + case ICAL_OBJECT_FIELD_URL: + return ico->url ? ico->url : ""; + + case ICAL_OBJECT_FIELD_HAS_ALARMS: + return (ico->dalarm.enabled || ico->aalarm.enabled + || ico->palarm.enabled || ico->malarm.enabled); + + default: + g_message ("calendar_model_value_at(): Requested invalid column %d", col); + return NULL; + } +} + + + +/** + * calendar_model_new: + * + * Creates a new calendar model. It must be told about the calendar client + * interface object it will monitor with calendar_model_set_cal_client(). + * + * Return value: A newly-created calendar model. + **/ +CalendarModel * +calendar_model_new (void) +{ + return CALENDAR_MODEL (gtk_type_new (TYPE_CALENDAR_MODEL)); +} + +/* Removes an object from the model and updates all the indices that follow. + * Returns the index of the object that was removed, or -1 if no object with + * such UID was found. + */ +static int +remove_object (CalendarModel *model, const char *uid) +{ + CalendarModelPrivate *priv; + int *idx; + iCalObject *orig_ico; + int i; + int n; + + priv = model->priv; + + /* Find the index of the object to be removed */ + + idx = g_hash_table_lookup (priv->uid_index_hash, uid); + if (!idx) + return -1; + + orig_ico = g_ptr_array_index (priv->objects, *idx); + g_assert (orig_ico != NULL); + + /* Decrease the indices of all the objects that follow in the array */ + + for (i = *idx + 1; i < priv->objects->len; i++) { + iCalObject *ico; + int *ico_idx; + + ico = g_ptr_array_index (priv->objects, i); + g_assert (ico != NULL); + + ico_idx = g_hash_table_lookup (priv->uid_index_hash, ico->uid); + g_assert (ico_idx != NULL); + + *ico_idx--; + g_assert (*ico_idx >= 0); + } + + /* Remove this object from the array and hash */ + + g_hash_table_remove (priv->uid_index_hash, uid); + g_array_remove (priv->objects, *idx); + + ical_object_unref (orig_ico); + + n = *idx; + g_free (idx); + + return n; +} + +/* Callback used when an object is updated in the server */ +static void +obj_updated_cb (CalClient *client, const char *uid, gpointer data) +{ + CalendarModel *model; + CalendarModelPrivate *priv; + int orig_idx; + + model = CALENDAR_MODEL (data); + priv = model->priv; + + orig_idx = remove_object (model, uid); + + + +} + +/* Loads the required objects from the calendar client */ +static void +load_objects (CalendarModel *model) +{ + CalendarModelPrivate *priv; + GList *uids; + GList *l; + + priv = model->priv; + + uids = cal_client_get_uids (priv->client, priv->type); + + for (l = uids; l; l = l->next) { + char *uid; + iCalObject *ico; + CalClientGetStatus status; + int *idx; + + uid = l->data; + status = cal_client_get_object (priv->client, uid, &ico); + + switch (status) { + case CAL_CLIENT_GET_SUCCESS: + break; + + case CAL_CLIENT_GET_NOT_FOUND: + /* Nothing; the object may have been removed from the server */ + continue; + + case CAL_CLIENT_GET_SYNTAX_ERROR: + g_message ("load_objects(): Syntax error when getting object %s", uid); + continue; + } + + g_assert (ico->uid != NULL); + + idx = g_new (int, 1); + + g_ptr_array_add (priv->objects, ico); + *idx = priv->objects->len - 1; + + g_hash_table_insert (priv->uid_index_hash, ico->uid, idx); + } + + cal_obj_uid_list_free (uids); +} + +/** + * calendar_model_set_cal_client: + * @model: A calendar model. + * @client: A calendar client interface object. + * @type: Type of objects to present. + * + * Sets the calendar client interface object that a calendar model will monitor. + * It also sets the types of objects this model will present to an #ETable. + **/ +void +calendar_model_set_cal_client (CalendarModel *model, CalClient *client, CalObjType type) +{ + CalendarModelPrivate *priv; + + g_return_if_fail (model != NULL); + g_return_if_fail (IS_CALENDAR_MODEL (model)); + + if (client) + g_return_if_fail (IS_CAL_CLIENT (client)); + + priv = model->priv; + + if (priv->client == client && priv->type == type) + return; + + if (client) + gtk_object_ref (GTK_OBJECT (client)); + + if (priv->client) { + gtk_signal_disconnect_by_data (GTK_OBJECT (priv->client), model); + gtk_object_unref (GTK_OBJECT (priv->client)); + } + + free_objects (model); + + priv->client = client; + priv->type = type; + + if (priv->client) { + gtk_signal_connect (GTK_OBJECT (priv->client), "obj_updated", + GTK_SIGNAL_FUNC (obj_updated_cb), model); + gtk_signal_connect (GTK_OBJECT (priv->clinet), "obj_removed", + GTK_SIGNAL_FUNC (obj_removed_cb), model); + } + + load_objects (model); + + e_table_model_changed (E_TABLE_MODEL (model)); +} diff --git a/calendar/gui/calendar-model.h b/calendar/gui/calendar-model.h new file mode 100644 index 0000000000..35b76a3807 --- /dev/null +++ b/calendar/gui/calendar-model.h @@ -0,0 +1,64 @@ +/* Evolution calendar - Data model for ETable + * + * Copyright (C) 2000 Helix Code, Inc. + * + * Authors: Federico Mena-Quintero + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef CALENDAR_MODEL_H +#define CALENDAR_MODEL_H + +#include +#include +#include + +BEGIN_GNOME_DECLS + + + +#define TYPE_CALENDAR_MODEL (calendar_model_get_type ()) +#define CALENDAR_MODEL(obj) (GTK_CHECK_CAST ((obj), TYPE_CALENDAR_MODEL, CalendarModel)) +#define CALENDAR_MODEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), TYPE_CALENDAR_MODEL, \ + CalendarModelClass)) +#define IS_CALENDAR_MODEL(obj) (GTK_CHECK_TYPE ((obj), TYPE_CALENDAR_MODEL)) +#define IS_CALENDAR_MODEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), TYPE_CALENDAR_MODEL)) + +typedef struct _CalendarModel CalendarModel; +typedef struct _CalendarModelClass CalendarModelClass; + +struct _CalendarModel { + ETableModel model; + + /* Private data */ + gpointer priv; +}; + +struct _CalendarModelClass { + ETableModelClass parent_class; +}; + +GtkType calendar_model_get_type (void); + +CalendarModel *calendar_model_new (); + +void calendar_model_set_cal_client (CalendarModel *model, CalClient *client, CalObjType type); + + + +END_GNOME_DECLS + +#endif -- cgit v1.2.3