/* Evolution calendar backend
*
* Copyright (C) 2000 Helix Code, Inc.
*
* Author: Federico Mena-Quintero <federico@helixcode.com>
*
* 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 <config.h>
#include "cal-backend.h"
#include "calobj.h"
#include "../libversit/vcc.h"
/* VCalendar product ID */
#define PRODID "-//Helix Code//NONSGML Tlacuache//EN"
/* Private part of the CalBackend structure */
typedef struct {
/* URI where the calendar data is stored */
GnomeVFSURI *uri;
/* List of Cal client interface objects, each with its listener */
GList *clients;
/* All the iCalObject structures in the calendar, hashed by UID. The
* hash key *is* icalobj->uid; it is not copied, so don't free it when
* you remove an object from the hash table.
*/
GHashTable *object_hash;
/* All events, TODOs, and journals in the calendar */
GList *events;
GList *todos;
GList *journals;
/* Whether a calendar has been loaded */
guint loaded : 1;
} CalBackendPrivate;
static void cal_backend_class_init (CalBackendClass *class);
static void cal_backend_init (CalBackend *backend);
static void cal_backend_destroy (GtkObject *object);
static GtkObjectClass *parent_class;
/**
* cal_backend_get_type:
* @void:
*
* Registers the #CalBackend class if necessary, and returns the type ID
* associated to it.
*
* Return value: The type ID of the #CalBackend class.
**/
GtkType
cal_backend_get_type (void)
{
static GtkType cal_backend_type = 0;
if (!cal_backend_type) {
static const GtkTypeInfo cal_backend_info = {
"CalBackend",
sizeof (CalBackend),
sizeof (CalBackendClass),
(GtkClassInitFunc) cal_backend_class_init,
(GtkObjectInitFunc) cal_backend_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
cal_backend_type = gtk_type_unique (GTK_TYPE_OBJECT, &cal_backend_info);
}
return cal_backend_type;
}
/* Class initialization function for the calendar backend */
static void
cal_backend_class_init (CalBackendClass *class)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass *) class;
parent_class = gtk_type_class (GTK_TYPE_OBJECT);
object_class->destroy = cal_backend_destroy;
}
/* Object initialization function for the calendar backend */
static void
cal_backend_init (CalBackend *backend)
{
CalBackendPrivate *priv;
priv = g_new0 (CalBackendPrivate, 1);
backend->priv = priv;
}
/* Destroy handler for the calendar backend */
static void
cal_backend_destroy (GtkObject *object)
{
CalBackend *backend;
CalBackendPrivate *priv;
g_return_if_fail (object != NULL);
g_return_if_fail (IS_CAL_BACKEND (object));
backend = CAL_BACKEND (object);
priv = backend->priv;
/* FIXME: free stuff */
g_free (priv);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
/* iCalObject manipulation functions */
/* Ensures that an iCalObject has a unique identifier. If it doesn't have one,
* it will create one for it. Returns whether an UID was created or not.
*/
static gboolean
ensure_uid (iCalObject *ico)
{
char *buf;
gulong str_time;
static guint seqno = 0;
if (ico->uid)
return FALSE;
str_time = (gulong) time (NULL);
/* Is this good enough? */
buf = g_strdup_printf ("Evolution-Tlacuache-%d-%ld-%u", (int) getpid(), str_time, seqno++);
ico->uid = buf;
return TRUE;
}
/* Adds an object to the calendar backend. Does *not* perform notification to
* calendar clients.
*/
static void
add_object (CalBackend *backend, iCalObject *ico)
{
CalBackendPrivate *priv;
g_assert (ico != NULL);
priv = backend->priv;
#if 0
/* FIXME: gnomecal old code */
ico->new = 0;
#endif
if (ensure_uid (ico))
/* FIXME: mark the calendar as dirty so that we can re-save it
* with the object's new UID.
*/
;
g_hash_table_insert (priv->object_hash, ico->uid, ico);
switch (ico->type) {
case ICAL_EVENT:
priv->events = g_list_prepend (priv->events, ico);
#if 0
/* FIXME: gnomecal old code */
ical_object_try_alarms (ico);
# ifdef DEBUGGING_MAIL_ALARM
ico->malarm.trigger = 0;
calendar_notify (0, ico);
# endif
#endif
break;
case ICAL_TODO:
priv->todos = g_list_prepend (priv->todos, ico);
break;
case ICAL_JOURNAL:
priv->journals = g_list_prepend (priv->journals, ico);
break;
default:
g_assert_not_reached ();
}
#if 0
/* FIXME: gnomecal old code */
ico->last_mod = time (NULL);
#endif
}
/* Load a calendar from a VObject */
static void
load_from_vobject (CalBackend *backend, VObject *vobject)
{
CalBackendPrivate *priv;
VObjectIterator i;
priv = backend->priv;
g_assert (!priv->loaded);
g_assert (priv->object_hash == NULL);
priv->object_hash = g_hash_table_new (g_str_hash, g_str_equal);
initPropIterator (&i, vobject);
while (moreIteration (&i)) {
VObject *this;
iCalObject *ical;
const char *object_name;
this = nextVObject (&i);
object_name = vObjectName (this);
#if 0
/* FIXME? What is this used for in gnomecal? */
if (strcmp (object_name, VCDCreatedProp) == 0) {
cal->created = time_from_isodate (str_val (this));
continue;
}
#endif
if (strcmp (object_name, VCLocationProp) == 0)
continue; /* FIXME: imlement */
if (strcmp (object_name, VCProdIdProp) == 0)
continue; /* FIXME: implement */
if (strcmp (object_name, VCVersionProp) == 0)
continue; /* FIXME: implement */
if (strcmp (object_name, VCTimeZoneProp) == 0)
continue; /* FIXME: implement */
ical = ical_object_create_from_vobject (this, object_name);
if (ical)
add_object (backend, ical);
}
}
/* Creates a VObject with the base information of a calendar */
static VObject *
get_calendar_base_vobject (CalBackend *backend)
{
VObject *vobj;
time_t now;
struct tm tm;
/* We call localtime for the side effect of setting tzname */
now = time (NULL);
tm = *localtime (&now);
vobj = newVObject (VCCalProp);
addPropValue (vobj, VCProdIdProp, PRODID);
#if defined (HAVE_TM_ZONE)
addPropValue (vobj, VCTimeZoneProp, tm.tm_zone);
#elif defined (HAVE_TZNAME)
addPropValue (vobj, VCTimeZoneProp, tzname[0]);
#endif
/* Per the vCalendar spec, this must be "1.0" */
addPropValue (vobj, VCVersionProp, "1.0");
return vobj;
}
/**
* cal_backend_new:
* @void:
*
* Creates a new empty calendar backend. A calendar must then be loaded or
* created before the backend can be used.
*
* Return value: A newly-created calendar backend.
**/
CalBackend *
cal_backend_new (void)
{
return CAL_BACKEND (gtk_type_new (CAL_BACKEND_TYPE));
}
/**
* cal_backend_get_uri:
* @backend: A calendar backend.
*
* Queries the URI of a calendar backend, which must already have a loaded
* calendar.
*
* Return value: The URI where the calendar is stored.
**/
GnomeVFSURI *
cal_backend_get_uri (CalBackend *backend)
{
CalBackendPrivate *priv;
g_return_val_if_fail (backend != NULL, NULL);
g_return_val_if_fail (IS_CAL_BACKEND (backend), NULL);
priv = backend->priv;
g_return_val_if_fail (priv->loaded, NULL);
g_assert (priv->uri != NULL);
return priv->uri;
}
/**
* cal_backend_add_cal:
* @backend: A calendar backend.
* @cal: A calendar client interface object.
*
* Adds a calendar client interface object to a calendar @backend. The calendar
* backend must already have a loaded calendar.
**/
void
cal_backend_add_cal (CalBackend *backend, Cal *cal)
{
CalBackendPrivate *priv;
g_return_if_fail (backend != NULL);
g_return_if_fail (IS_CAL_BACKEND (backend));
priv = backend->priv;
g_return_if_fail (priv->loaded);
g_return_if_fail (cal != NULL);
g_return_if_fail (IS_CAL (cal));
gtk_object_ref (GTK_OBJECT (cal));
priv->clients = g_list_prepend (priv->clients, cal);
}
/**
* cal_backend_remove_cal:
* @backend: A calendar backend.
* @cal: A calendar client interface object.
*
* Removes a calendar client interface object from a calendar backend. The
* calendar backend must already have a loaded calendar.
**/
void
cal_backend_remove_cal (CalBackend *backend, Cal *cal)
{
CalBackendPrivate *priv;
GList *l;
g_return_if_fail (backend != NULL);
g_return_if_fail (IS_CAL_BACKEND (backend));
priv = backend->priv;
g_return_if_fail (priv->loaded);
g_return_if_fail (cal != NULL);
g_return_if_fail (IS_CAL (cal));
l = g_list_find (priv->clients, cal);
if (!l)
return;
gtk_object_unref (GTK_OBJECT (cal));
priv->clients = g_list_remove_link (priv->clients, l);
g_list_free_1 (l);
}
/**
* cal_backend_load:
* @backend: A calendar backend.
* @uri: URI that contains the calendar data.
*
* Loads a calendar backend with data from a calendar stored at the specified
* URI.
*
* Return value: An operation status code.
**/
CalBackendLoadStatus
cal_backend_load (CalBackend *backend, GnomeVFSURI *uri)
{
CalBackendPrivate *priv;
VObject *vobject;
char *str_uri;
g_return_val_if_fail (backend != NULL, CAL_BACKEND_LOAD_ERROR);
g_return_val_if_fail (IS_CAL_BACKEND (backend), CAL_BACKEND_LOAD_ERROR);
g_return_val_if_fail (uri != NULL, CAL_BACKEND_LOAD_ERROR);
priv = backend->priv;
g_return_val_if_fail (!priv->loaded, CAL_BACKEND_LOAD_ERROR);
/* FIXME: this looks rather bad; maybe we should check for local files
* and fail if they are remote.
*/
str_uri = gnome_vfs_uri_to_string (uri,
(GNOME_VFS_URI_HIDE_USER_NAME
| GNOME_VFS_URI_HIDE_PASSWORD
| GNOME_VFS_URI_HIDE_HOST_NAME
| GNOME_VFS_URI_HIDE_HOST_PORT
| GNOME_VFS_URI_HIDE_TOPLEVEL_METHOD));
vobject = Parse_MIME_FromFileName (str_uri);
g_free (str_uri);
if (!vobject)
return CAL_BACKEND_LOAD_ERROR;
load_from_vobject (backend, vobject);
cleanVObject (vobject);
cleanStrTbl ();
gnome_vfs_uri_ref (uri);
priv->uri = uri;
priv->loaded = TRUE;
return CAL_BACKEND_LOAD_SUCCESS;
}
/**
* cal_backend_get_object:
* @backend: A calendar backend.
* @uid: Unique identifier for a calendar object.
*
* Queries a calendar backend for a calendar object based on its unique
* identifier.
*
* Return value: The string representation of a complete calendar wrapping the
* the sought object, or NULL if no object had the specified UID. A complete
* calendar is returned because you also need the timezone data.
**/
char *
cal_backend_get_object (CalBackend *backend, const char *uid)
{
CalBackendPrivate *priv;
iCalObject *ico;
VObject *vcalobj, *vobj;
char *buf;
g_return_val_if_fail (backend != NULL, NULL);
g_return_val_if_fail (IS_CAL_BACKEND (backend), NULL);
priv = backend->priv;
g_return_val_if_fail (priv->loaded, NULL);
g_return_val_if_fail (uid != NULL, NULL);
g_assert (priv->object_hash != NULL);
ico = g_hash_table_lookup (priv->objec_hash, uid);
if (!ico)
return NULL;
vcalobj = get_calendar_base_vobject (backend);
vobj = ical_object_to_vobject (ico);
addVObjectProp (vcalobj, vobj);
buf = writeMemVObject (NULL, NULL, vcalobj);
cleanVObject (vcalobj);
cleanStrTbl ();
return buf;
}
