aboutsummaryrefslogtreecommitdiffstats
path: root/calendar/pcs
diff options
context:
space:
mode:
Diffstat (limited to 'calendar/pcs')
-rw-r--r--calendar/pcs/Makefile.am4
-rw-r--r--calendar/pcs/cal-backend-db.c17
-rw-r--r--calendar/pcs/cal-backend-file.c31
-rw-r--r--calendar/pcs/cal-backend.c125
-rw-r--r--calendar/pcs/cal-backend.h13
-rw-r--r--calendar/pcs/cal.c40
-rw-r--r--calendar/pcs/query.c780
-rw-r--r--calendar/pcs/query.h69
8 files changed, 1067 insertions, 12 deletions
diff --git a/calendar/pcs/Makefile.am b/calendar/pcs/Makefile.am
index 984dcde86a..18156b4881 100644
--- a/calendar/pcs/Makefile.am
+++ b/calendar/pcs/Makefile.am
@@ -35,7 +35,9 @@ libpcs_a_SOURCES = \
cal-factory.c \
cal-factory.h \
job.c \
- job.h
+ job.h \
+ query.c \
+ query.h
BUILT_SOURCES = $(CORBA_GENERATED)
diff --git a/calendar/pcs/cal-backend-db.c b/calendar/pcs/cal-backend-db.c
index fca87bd9ab..d4773760f8 100644
--- a/calendar/pcs/cal-backend-db.c
+++ b/calendar/pcs/cal-backend-db.c
@@ -67,6 +67,7 @@ static void cal_backend_db_add_cal (CalBackend *backend, Cal *cal);
static CalBackendOpenStatus cal_backend_db_open (CalBackend *backend,
GnomeVFSURI *uri,
gboolean only_if_exists);
+static gboolean cal_backend_db_is_loaded (CalBackend *backend);
static int cal_backend_db_get_n_objects (CalBackend *backend, CalObjType type);
static char *cal_backend_db_get_object (CalBackend *backend, const char *uid);
@@ -150,6 +151,7 @@ cal_backend_db_class_init (CalBackendDBClass *klass)
backend_class->get_uri = cal_backend_db_get_uri;
backend_class->add_cal = cal_backend_db_add_cal;
backend_class->open = cal_backend_db_open;
+ backend_class->is_loaded = cal_backend_db_is_loaded;
backend_class->get_n_objects = cal_backend_db_get_n_objects;
backend_class->get_object = cal_backend_db_get_object;
backend_class->get_type_by_uid = cal_backend_db_get_type_by_uid;
@@ -589,6 +591,17 @@ cal_backend_db_open (CalBackend *backend, GnomeVFSURI *uri, gboolean only_if_exi
return CAL_BACKEND_OPEN_SUCCESS;
}
+/* is_loaded handler for the DB backend */
+static gboolean
+cal_backend_db_is_loaded (CalBackend *backend)
+{
+ CalBackendDB *cbdb;
+
+ cbdb = CAL_BACKEND_DB (backend);
+
+ return (cbdb->priv->uri != NULL);
+}
+
/* get_n_objects handler for the DB backend */
static int
cal_backend_db_get_n_objects (CalBackend *backend, CalObjType type)
@@ -1445,7 +1458,8 @@ cal_backend_db_update_object (CalBackend *backend, const char *uid, const char *
return FALSE;
}
commit_transaction(tid);
-
+
+ cal_backend_obj_updated (CAL_BACKEND (cbdb), uid);
do_notify(cbdb, cal_notify_update, uid);
return TRUE;
}
@@ -1482,6 +1496,7 @@ cal_backend_db_remove_object (CalBackend *backend, const char *uid)
/* TODO: update history database */
commit_transaction(tid);
+ cal_backend_obj_removed (CAL_BACKEND (cbdb), uid);
do_notify(cbdb, cal_notify_remove, uid);
return TRUE;
diff --git a/calendar/pcs/cal-backend-file.c b/calendar/pcs/cal-backend-file.c
index b3b3196324..a624db9f12 100644
--- a/calendar/pcs/cal-backend-file.c
+++ b/calendar/pcs/cal-backend-file.c
@@ -69,6 +69,7 @@ static GnomeVFSURI *cal_backend_file_get_uri (CalBackend *backend);
static void cal_backend_file_add_cal (CalBackend *backend, Cal *cal);
static CalBackendOpenStatus cal_backend_file_open (CalBackend *backend, GnomeVFSURI *uri,
gboolean only_if_exists);
+static gboolean cal_backend_file_is_loaded (CalBackend *backend);
static int cal_backend_file_get_n_objects (CalBackend *backend, CalObjType type);
static char *cal_backend_file_get_object (CalBackend *backend, const char *uid);
@@ -143,6 +144,7 @@ cal_backend_file_class_init (CalBackendFileClass *class)
backend_class->get_uri = cal_backend_file_get_uri;
backend_class->add_cal = cal_backend_file_add_cal;
backend_class->open = cal_backend_file_open;
+ backend_class->is_loaded = cal_backend_file_is_loaded;
backend_class->get_n_objects = cal_backend_file_get_n_objects;
backend_class->get_object = cal_backend_file_get_object;
backend_class->get_type_by_uid = cal_backend_file_get_type_by_uid;
@@ -163,6 +165,14 @@ cal_backend_file_init (CalBackendFile *cbfile)
priv = g_new0 (CalBackendFilePrivate, 1);
cbfile->priv = priv;
+
+ priv->uri = NULL;
+ priv->clients = NULL;
+ priv->icalcomp = NULL;
+ priv->comp_uid_hash = NULL;
+ priv->events = NULL;
+ priv->todos = NULL;
+ priv->journals = NULL;
}
/* g_hash_table_foreach() callback to destroy a CalComponent */
@@ -640,8 +650,10 @@ open_cal (CalBackendFile *cbfile, GnomeVFSURI *uri, FILE *file)
* individual components as well?
*/
- if (icalcomponent_isa (icalcomp) != ICAL_VCALENDAR_COMPONENT)
+ if (icalcomponent_isa (icalcomp) != ICAL_VCALENDAR_COMPONENT) {
+ icalcomponent_free (icalcomp);
return CAL_BACKEND_OPEN_ERROR;
+ }
priv->icalcomp = icalcomp;
@@ -734,6 +746,19 @@ cal_backend_file_open (CalBackend *backend, GnomeVFSURI *uri, gboolean only_if_e
}
}
+/* is_loaded handler for the file backend */
+static gboolean
+cal_backend_file_is_loaded (CalBackend *backend)
+{
+ CalBackendFile *cbfile;
+ CalBackendFilePrivate *priv;
+
+ cbfile = CAL_BACKEND_FILE (backend);
+ priv = cbfile->priv;
+
+ return (priv->icalcomp != NULL);
+}
+
/* Get_n_objects handler for the file backend */
static int
cal_backend_file_get_n_objects (CalBackend *backend, CalObjType type)
@@ -1469,6 +1494,8 @@ notify_update (CalBackendFile *cbfile, const char *uid)
priv = cbfile->priv;
+ cal_backend_obj_updated (CAL_BACKEND (cbfile), uid);
+
for (l = priv->clients; l; l = l->next) {
Cal *cal;
@@ -1486,6 +1513,8 @@ notify_remove (CalBackendFile *cbfile, const char *uid)
priv = cbfile->priv;
+ cal_backend_obj_removed (CAL_BACKEND (cbfile), uid);
+
for (l = priv->clients; l; l = l->next) {
Cal *cal;
diff --git a/calendar/pcs/cal-backend.c b/calendar/pcs/cal-backend.c
index ce53cda78a..350e6468e4 100644
--- a/calendar/pcs/cal-backend.c
+++ b/calendar/pcs/cal-backend.c
@@ -37,6 +37,9 @@
/* Signal IDs */
enum {
LAST_CLIENT_GONE,
+ OPENED,
+ OBJ_UPDATED,
+ OBJ_REMOVED,
LAST_SIGNAL
};
@@ -96,8 +99,51 @@ cal_backend_class_init (CalBackendClass *class)
GTK_SIGNAL_OFFSET (CalBackendClass, last_client_gone),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
+ cal_backend_signals[OPENED] =
+ gtk_signal_new ("opened",
+ GTK_RUN_FIRST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (CalBackendClass, opened),
+ gtk_marshal_NONE__ENUM,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_ENUM);
+ cal_backend_signals[OBJ_UPDATED] =
+ gtk_signal_new ("obj_updated",
+ GTK_RUN_FIRST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (CalBackendClass, obj_updated),
+ gtk_marshal_NONE__STRING,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_STRING);
+ cal_backend_signals[OBJ_REMOVED] =
+ gtk_signal_new ("obj_removed",
+ GTK_RUN_FIRST,
+ object_class->type,
+ GTK_SIGNAL_OFFSET (CalBackendClass, obj_removed),
+ gtk_marshal_NONE__STRING,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_STRING);
gtk_object_class_add_signals (object_class, cal_backend_signals, LAST_SIGNAL);
+
+ class->last_client_gone = NULL;
+ class->opened = NULL;
+ class->obj_updated = NULL;
+ class->obj_removed = NULL;
+
+ class->get_uri = NULL;
+ class->add_cal = NULL;
+ class->open = NULL;
+ class->get_n_objects = NULL;
+ class->get_object = NULL;
+ class->get_type_by_uid = NULL;
+ class->get_uids = NULL;
+ class->get_objects_in_range = NULL;
+ class->get_changes = NULL;
+ class->get_alarms_in_range = NULL;
+ class->get_alarms_for_object = NULL;
+ class->update_object = NULL;
+ class->remove_object = NULL;
}
@@ -162,7 +208,29 @@ cal_backend_open (CalBackend *backend, GnomeVFSURI *uri, gboolean only_if_exists
g_return_val_if_fail (uri != NULL, CAL_BACKEND_OPEN_ERROR);
g_assert (CLASS (backend)->open != NULL);
- result = (* CLASS (backend)->open) (backend, uri, only_if_exists);
+ result = (* CLASS (backend)->open) (backend, uri, only_if_exists);
+
+ return result;
+}
+
+/**
+ * cal_backend_is_loaded:
+ * @backend: A calendar backend.
+ *
+ * Queries whether a calendar backend has been loaded yet.
+ *
+ * Return value: TRUE if the backend has been loaded with data, FALSE otherwise.
+ **/
+gboolean
+cal_backend_is_loaded (CalBackend *backend)
+{
+ gboolean result;
+
+ g_return_val_if_fail (backend != NULL, FALSE);
+ g_return_val_if_fail (IS_CAL_BACKEND (backend), FALSE);
+
+ g_assert (CLASS (backend)->is_loaded != NULL);
+ result = (* CLASS (backend)->is_loaded) (backend);
return result;
}
@@ -417,3 +485,58 @@ cal_backend_last_client_gone (CalBackend *backend)
gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[LAST_CLIENT_GONE]);
}
+/**
+ * cal_backend_opened:
+ * @backend: A calendar backend.
+ * @status: Open status code.
+ *
+ * Emits the "opened" signal of a calendar backend. This function is to be used
+ * only by backend implementations.
+ **/
+void
+cal_backend_opened (CalBackend *backend, CalBackendOpenStatus status)
+{
+ g_return_if_fail (backend != NULL);
+ g_return_if_fail (IS_CAL_BACKEND (backend));
+
+ gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OPENED],
+ status);
+}
+
+/**
+ * cal_backend_obj_updated:
+ * @backend: A calendar backend.
+ * @uid: Unique identifier of the component that was updated.
+ *
+ * Emits the "obj_updated" signal of a calendar backend. This function is to be
+ * used only by backend implementations.
+ **/
+void
+cal_backend_obj_updated (CalBackend *backend, const char *uid)
+{
+ g_return_if_fail (backend != NULL);
+ g_return_if_fail (IS_CAL_BACKEND (backend));
+ g_return_if_fail (uid != NULL);
+
+ gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OBJ_UPDATED],
+ uid);
+}
+
+/**
+ * cal_backend_obj_removed:
+ * @backend: A calendar backend.
+ * @uid: Unique identifier of the component that was removed.
+ *
+ * Emits the "obj_removed" signal of a calendar backend. This function is to be
+ * used only by backend implementations.
+ **/
+void
+cal_backend_obj_removed (CalBackend *backend, const char *uid)
+{
+ g_return_if_fail (backend != NULL);
+ g_return_if_fail (IS_CAL_BACKEND (backend));
+ g_return_if_fail (uid != NULL);
+
+ gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OBJ_REMOVED],
+ uid);
+}
diff --git a/calendar/pcs/cal-backend.h b/calendar/pcs/cal-backend.h
index 3784601ddf..dab06b21e8 100644
--- a/calendar/pcs/cal-backend.h
+++ b/calendar/pcs/cal-backend.h
@@ -43,7 +43,7 @@ BEGIN_GNOME_DECLS
#define IS_CAL_BACKEND(obj) (GTK_CHECK_TYPE ((obj), CAL_BACKEND_TYPE))
#define IS_CAL_BACKEND_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), CAL_BACKEND_TYPE))
-/* Load status values */
+/* Open status values */
typedef enum {
CAL_BACKEND_OPEN_SUCCESS, /* Loading OK */
CAL_BACKEND_OPEN_ERROR, /* We need better error reporting in libversit */
@@ -67,6 +67,10 @@ struct _CalBackendClass {
/* Notification signals */
void (* last_client_gone) (CalBackend *backend);
+ void (* opened) (CalBackend *backend, CalBackendOpenStatus status);
+ void (* obj_updated) (CalBackend *backend, const char *uid);
+ void (* obj_removed) (CalBackend *backend, const char *uid);
+
/* Virtual methods */
GnomeVFSURI *(* get_uri) (CalBackend *backend);
void (* add_cal) (CalBackend *backend, Cal *cal);
@@ -74,6 +78,8 @@ struct _CalBackendClass {
CalBackendOpenStatus (* open) (CalBackend *backend, GnomeVFSURI *uri,
gboolean only_if_exists);
+ gboolean (* is_loaded) (CalBackend *backend);
+
/* General object acquirement and information related virtual methods */
int (* get_n_objects) (CalBackend *backend, CalObjType type);
char *(* get_object) (CalBackend *backend, const char *uid);
@@ -108,6 +114,8 @@ void cal_backend_add_cal (CalBackend *backend, Cal *cal);
CalBackendOpenStatus cal_backend_open (CalBackend *backend, GnomeVFSURI *uri,
gboolean only_if_exists);
+gboolean cal_backend_is_loaded (CalBackend *backend);
+
int cal_backend_get_n_objects (CalBackend *backend, CalObjType type);
char *cal_backend_get_object (CalBackend *backend, const char *uid);
@@ -134,6 +142,9 @@ gboolean cal_backend_update_object (CalBackend *backend, const char *uid, const
gboolean cal_backend_remove_object (CalBackend *backend, const char *uid);
void cal_backend_last_client_gone (CalBackend *backend);
+void cal_backend_opened (CalBackend *backend, CalBackendOpenStatus status);
+void cal_backend_obj_updated (CalBackend *backend, const char *uid);
+void cal_backend_obj_removed (CalBackend *backend, const char *uid);
diff --git a/calendar/pcs/cal.c b/calendar/pcs/cal.c
index 69eccd7f55..3129665466 100644
--- a/calendar/pcs/cal.c
+++ b/calendar/pcs/cal.c
@@ -22,7 +22,7 @@
#include <config.h>
#include "cal.h"
-#include "cal-backend.h"
+#include "query.h"
@@ -446,6 +446,31 @@ Cal_remove_object (PortableServer_Servant servant,
NULL);
}
+/* Cal::getQuery implementation */
+static GNOME_Evolution_Calendar_Query
+Cal_get_query (PortableServer_Servant servant,
+ const CORBA_char *sexp,
+ GNOME_Evolution_Calendar_QueryListener ql,
+ CORBA_Environment *ev)
+{
+ Cal *cal;
+ CalPrivate *priv;
+ Query *query;
+
+ cal = CAL (bonobo_object_from_servant (servant));
+ priv = cal->priv;
+
+ query = query_new (priv->backend, ql, sexp);
+ if (!query) {
+ CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
+ ex_GNOME_Evolution_Calendar_Cal_CouldNotCreate,
+ NULL);
+ return CORBA_OBJECT_NIL;
+ }
+
+ return BONOBO_OBJREF (query);
+}
+
/**
* cal_get_epv:
* @void:
@@ -460,16 +485,17 @@ cal_get_epv (void)
POA_GNOME_Evolution_Calendar_Cal__epv *epv;
epv = g_new0 (POA_GNOME_Evolution_Calendar_Cal__epv, 1);
- epv->_get_uri = Cal_get_uri;
+ epv->_get_uri = Cal_get_uri;
epv->countObjects = Cal_get_n_objects;
- epv->getObject = Cal_get_object;
- epv->getUIds = Cal_get_uids;
- epv->getChanges = Cal_get_changes;
- epv->getObjectsInRange = Cal_get_objects_in_range;
- epv->getAlarmsInRange = Cal_get_alarms_in_range;
+ epv->getObject = Cal_get_object;
+ epv->getUIDs = Cal_get_uids;
+ epv->getChanges = Cal_get_changes;
+ epv->getObjectsInRange = Cal_get_objects_in_range;
+ epv->getAlarmsInRange = Cal_get_alarms_in_range;
epv->getAlarmsForObject = Cal_get_alarms_for_object;
epv->updateObject = Cal_update_object;
epv->removeObject = Cal_remove_object;
+ epv->getQuery = Cal_get_query;
return epv;
}
diff --git a/calendar/pcs/query.c b/calendar/pcs/query.c
new file mode 100644
index 0000000000..708a160794
--- /dev/null
+++ b/calendar/pcs/query.c
@@ -0,0 +1,780 @@
+/* Evolution calendar - Live search query implementation
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Author: Federico Mena-Quintero <federico@ximian.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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <glib.h>
+#include <libgnome/gnome-defs.h>
+#include <libgnome/gnome-i18n.h>
+#include <gtk/gtksignal.h>
+#include <e-util/e-sexp.h>
+#include <cal-util/cal-recur.h>
+#include "query.h"
+
+
+
+/* Private part of the Query structure */
+struct _QueryPrivate {
+ /* The backend we are monitoring */
+ CalBackend *backend;
+
+ /* Listener to which we report changes in the live query */
+ GNOME_Evolution_Calendar_QueryListener ql;
+
+ /* Sexp that defines the query */
+ char *sexp;
+ ESExp *esexp;
+
+ /* Idle handler ID for asynchronous queries */
+ guint idle_id;
+
+ /* List of UIDs that we still have to process */
+ GList *pending_uids;
+ int n_pending;
+ int pending_total;
+
+ /* Table of the UIDs we know do match the query */
+ GHashTable *uids;
+
+ /* The next component that will be handled in e_sexp_eval(); put here
+ * just because the query object itself is the esexp context.
+ */
+ CalComponent *next_comp;
+};
+
+
+
+static void query_class_init (QueryClass *class);
+static void query_init (Query *query);
+static void query_destroy (GtkObject *object);
+
+static BonoboXObjectClass *parent_class;
+
+
+
+BONOBO_X_TYPE_FUNC_FULL (Query,
+ GNOME_Evolution_Calendar_Query,
+ BONOBO_X_OBJECT_TYPE,
+ query);
+
+/* Class initialization function for the live search query */
+static void
+query_class_init (QueryClass *class)
+{
+ GtkObjectClass *object_class;
+
+ object_class = (GtkObjectClass *) class;
+
+ parent_class = gtk_type_class (BONOBO_X_OBJECT_TYPE);
+
+ object_class->destroy = query_destroy;
+
+ /* The Query interface (ha ha! query interface!) has no methods, so we
+ * don't need to fiddle with the epv.
+ */
+}
+
+/* Object initialization function for the live search query */
+static void
+query_init (Query *query)
+{
+ QueryPrivate *priv;
+
+ priv = g_new0 (QueryPrivate, 1);
+ query->priv = priv;
+
+ priv->backend = NULL;
+ priv->ql = CORBA_OBJECT_NIL;
+ priv->sexp = NULL;
+
+ priv->pending_uids = NULL;
+ priv->uids = g_hash_table_new (g_str_hash, g_str_equal);
+
+ priv->next_comp = NULL;
+}
+
+/* Used from g_hash_table_foreach(); frees a UID */
+static void
+free_uid_cb (gpointer key, gpointer value, gpointer data)
+{
+ char *uid;
+
+ uid = key;
+ g_free (uid);
+}
+
+/* Destroy handler for the live search query */
+static void
+query_destroy (GtkObject *object)
+{
+ Query *query;
+ QueryPrivate *priv;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (IS_QUERY (object));
+
+ query = QUERY (object);
+ priv = query->priv;
+
+ if (priv->backend) {
+ gtk_object_unref (GTK_OBJECT (priv->backend));
+ priv->backend = NULL;
+ }
+
+ if (priv->ql != CORBA_OBJECT_NIL) {
+ CORBA_Environment ev;
+
+ CORBA_exception_init (&ev);
+ bonobo_object_release_unref (priv->ql, &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("query_destroy(): Could not unref the listener\n");
+
+ CORBA_exception_free (&ev);
+
+ priv->ql = CORBA_OBJECT_NIL;
+ }
+
+ if (priv->sexp) {
+ g_free (priv->sexp);
+ priv->sexp = NULL;
+ }
+
+ if (priv->esexp) {
+ e_sexp_unref (priv->esexp);
+ priv->esexp = NULL;
+ }
+
+ if (priv->idle_id) {
+ g_source_remove (priv->idle_id);
+ priv->idle_id = 0;
+ }
+
+ if (priv->pending_uids) {
+ GList *l;
+
+ for (l = priv->pending_uids; l; l = l->next) {
+ char *uid;
+
+ uid = l->data;
+ g_assert (uid != NULL);
+ g_free (uid);
+ }
+
+ g_list_free (priv->pending_uids);
+ priv->pending_uids = NULL;
+ priv->n_pending = 0;
+ }
+
+ g_hash_table_foreach (priv->uids, free_uid_cb, NULL);
+ g_hash_table_destroy (priv->uids);
+ priv->uids = NULL;
+
+ g_free (priv);
+ query->priv = NULL;
+
+ if (GTK_OBJECT_CLASS (parent_class)->destroy)
+ (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
+
+
+/* Search engine functions */
+
+/* (get-vtype)
+ *
+ * Returns a string indicating the type of component (VEVENT, VTODO, VJOURNAL,
+ * VFREEBUSY, VTIMEZONE, UNKNOWN).
+ */
+static ESExpResult *
+func_get_vtype (ESExp *esexp, int argc, ESExpResult **argv, void *data)
+{
+ Query *query;
+ QueryPrivate *priv;
+ CalComponent *comp;
+ CalComponentVType vtype;
+ char *str;
+ ESExpResult *result;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ g_assert (priv->next_comp != NULL);
+ comp = priv->next_comp;
+
+ /* Check argument types */
+
+ if (argc != 0) {
+ e_sexp_fatal_error (esexp, _("get-vtype expects 0 arguments"));
+ return NULL;
+ }
+
+ /* Get the type */
+
+ vtype = cal_component_get_vtype (comp);
+
+ switch (vtype) {
+ case CAL_COMPONENT_EVENT:
+ str = g_strdup ("VEVENT");
+ break;
+
+ case CAL_COMPONENT_TODO:
+ str = g_strdup ("VTODO");
+ break;
+
+ case CAL_COMPONENT_JOURNAL:
+ str = g_strdup ("VJOURNAL");
+ break;
+
+ case CAL_COMPONENT_FREEBUSY:
+ str = g_strdup ("VFREEBUSY");
+ break;
+
+ case CAL_COMPONENT_TIMEZONE:
+ str = g_strdup ("VTIMEZONE");
+ break;
+
+ default:
+ str = g_strdup ("UNKNOWN");
+ break;
+ }
+
+ result = e_sexp_result_new (esexp, ESEXP_RES_STRING);
+ result->value.string = str;
+
+ return result;
+}
+
+/* Sets a boolean value in the data to TRUE; called from
+ * cal_recur_generate_instances() to indicate that at least one instance occurs
+ * in the sought time range. We always return FALSE because we want the
+ * recurrence engine to finish as soon as possible.
+ */
+static gboolean
+instance_occur_cb (CalComponent *comp, time_t start, time_t end, gpointer data)
+{
+ gboolean *occurs;
+
+ occurs = data;
+ *occurs = TRUE;
+
+ return FALSE;
+}
+
+/* (occur-in-time-range? START END)
+ *
+ * START - int, time_t start of the time range
+ * END - int, time_t end of the time range
+ *
+ * Returns a boolean indicating whether the component has any occurrences in the
+ * specified time range.
+ *
+ * We may prefer to switch this to a string representation of times (ISO 8601,
+ * perhaps). */
+static ESExpResult *
+func_occur_in_time_range (ESExp *esexp, int argc, ESExpResult **argv, void *data)
+{
+ Query *query;
+ QueryPrivate *priv;
+ CalComponent *comp;
+ time_t start, end;
+ gboolean occurs;
+ ESExpResult *result;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ g_assert (priv->next_comp != NULL);
+ comp = priv->next_comp;
+
+ /* Check argument types */
+
+ if (argc != 2) {
+ e_sexp_fatal_error (esexp, _("occur-in-time-range? expects 2 arguments"));
+ return NULL;
+ }
+
+ if (argv[0]->type != ESEXP_RES_INT) {
+ e_sexp_fatal_error (esexp, _("occur-in-time-range? expects argument 1 "
+ "to be an integer"));
+ return NULL;
+ }
+ start = argv[0]->value.number;
+
+ if (argv[1]->type != ESEXP_RES_INT) {
+ e_sexp_fatal_error (esexp, _("occur-in-time-range? expects argument 2 "
+ "to be an integer"));
+ return NULL;
+ }
+ end = argv[1]->value.number;
+
+ /* See if there is at least one instance in that range */
+
+ occurs = FALSE;
+ cal_recur_generate_instances (comp, start, end, instance_occur_cb, &occurs);
+
+ result = e_sexp_result_new (esexp, ESEXP_RES_BOOL);
+ result->value.bool = occurs;
+
+ return result;
+}
+
+
+
+/* Adds a component to our the UIDs hash table and notifies the client */
+static void
+add_component (Query *query, const char *uid, gboolean query_in_progress, int n_scanned, int total)
+{
+ QueryPrivate *priv;
+ char *old_uid;
+ CORBA_Environment ev;
+
+ if (query_in_progress)
+ g_assert (n_scanned > 0 || n_scanned <= total);
+
+ priv = query->priv;
+
+ if (g_hash_table_lookup_extended (priv->uids, uid, (gpointer *) &old_uid, NULL)) {
+ g_hash_table_remove (priv->uids, old_uid);
+ g_free (old_uid);
+ }
+
+ g_hash_table_insert (priv->uids, g_strdup (uid), NULL);
+
+ CORBA_exception_init (&ev);
+ GNOME_Evolution_Calendar_QueryListener_notifyObjUpdated (
+ priv->ql,
+ (char *) uid,
+ query_in_progress,
+ n_scanned,
+ total,
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("add_component(): Could not notify the listener of an "
+ "updated component");
+
+ CORBA_exception_free (&ev);
+}
+
+/* Removes a component from our the UIDs hash table and notifies the client */
+static void
+remove_component (Query *query, const char *uid)
+{
+ QueryPrivate *priv;
+ char *old_uid;
+ CORBA_Environment ev;
+
+ priv = query->priv;
+
+ if (!g_hash_table_lookup_extended (priv->uids, uid, (gpointer *) &old_uid, NULL))
+ return;
+
+ /* The component did match the query before but it no longer does, so we
+ * have to notify the client.
+ */
+
+ g_hash_table_remove (priv->uids, old_uid);
+ g_free (old_uid);
+
+ CORBA_exception_init (&ev);
+ GNOME_Evolution_Calendar_QueryListener_notifyObjRemoved (
+ priv->ql,
+ (char *) uid,
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("remove_component(): Could not notify the listener of a "
+ "removed component");
+
+ CORBA_exception_free (&ev);
+}
+
+/* Removes a component from the list of pending UIDs */
+static void
+remove_from_pending (Query *query, const char *remove_uid)
+{
+ QueryPrivate *priv;
+ GList *l;
+
+ priv = query->priv;
+
+ for (l = priv->pending_uids; l; l = l->next) {
+ char *uid;
+
+ g_assert (priv->n_pending > 0);
+
+ uid = l->data;
+ if (strcmp (remove_uid, uid))
+ continue;
+
+ g_free (uid);
+
+ priv->pending_uids = g_list_remove_link (priv->pending_uids, l);
+ g_list_free_1 (l);
+ priv->n_pending--;
+
+ g_assert ((priv->pending_uids && priv->n_pending != 0)
+ || (!priv->pending_uids && priv->n_pending == 0));
+
+ break;
+ }
+}
+
+static struct {
+ char *name;
+ ESExpFunc *func;
+} functions[] = {
+ { "get-vtype", func_get_vtype },
+ { "occur-in-time-range?", func_occur_in_time_range }
+};
+
+/* Initializes a sexp by interning our own symbols */
+static ESExp *
+create_sexp (Query *query)
+{
+ ESExp *esexp;
+ int i;
+
+ esexp = e_sexp_new ();
+
+ for (i = 0; i < (sizeof (functions) / sizeof (functions[0])); i++)
+ e_sexp_add_function (esexp, 0, functions[i].name, functions[i].func, query);
+
+ return esexp;
+}
+
+/* Evaluates the query sexp on the specified component and notifies the listener
+ * as appropriate.
+ */
+static void
+match_component (Query *query, const char *uid,
+ gboolean query_in_progress, int n_scanned, int total)
+{
+ QueryPrivate *priv;
+ char *comp_str;
+ CalComponent *comp;
+ icalcomponent *icalcomp;
+ gboolean set_succeeded;
+ ESExpResult *result;
+
+ priv = query->priv;
+
+ comp_str = cal_backend_get_object (priv->backend, uid);
+ g_assert (comp_str != NULL);
+
+ icalcomp = icalparser_parse_string (comp_str);
+ g_assert (icalcomp != NULL);
+
+ comp = cal_component_new ();
+ set_succeeded = cal_component_set_icalcomponent (comp, icalcomp);
+ g_assert (set_succeeded);
+
+ /* Eval the sexp */
+
+ g_assert (priv->next_comp == NULL);
+
+ priv->next_comp = comp;
+ result = e_sexp_eval (priv->esexp);
+ gtk_object_unref (GTK_OBJECT (comp));
+ priv->next_comp = NULL;
+
+ if (!result) {
+ const char *error_str;
+ CORBA_Environment ev;
+
+ error_str = e_sexp_error (priv->esexp);
+ g_assert (error_str != NULL);
+
+ CORBA_exception_init (&ev);
+ GNOME_Evolution_Calendar_QueryListener_notifyEvalError (
+ priv->ql,
+ error_str,
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("process_component_cb(): Could not notify the listener of "
+ "an evaluation error");
+
+ CORBA_exception_free (&ev);
+ } else if (result->type != ESEXP_RES_BOOL) {
+ CORBA_Environment ev;
+
+ CORBA_exception_init (&ev);
+ GNOME_Evolution_Calendar_QueryListener_notifyEvalError (
+ priv->ql,
+ _("Evaluation of the search expression did not yield a boolean value"),
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("process_component_cb(): Could not notify the listener of "
+ "an unexpected result value type when evaluating the "
+ "search expression");
+
+ CORBA_exception_free (&ev);
+ } else {
+ /* Success; process the component accordingly */
+
+ if (result->value.bool)
+ add_component (query, uid, query_in_progress, n_scanned, total);
+ else
+ remove_component (query, uid);
+ }
+}
+
+/* Processes a single component that is queued in the list */
+static gboolean
+process_component_cb (gpointer data)
+{
+ Query *query;
+ QueryPrivate *priv;
+ char *uid;
+ GList *l;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ /* No more components? */
+
+ if (!priv->pending_uids) {
+ g_assert (priv->n_pending == 0);
+
+ g_source_remove (priv->idle_id);
+ priv->idle_id = 0;
+ return FALSE;
+ }
+
+ g_assert (priv->n_pending > 0);
+
+ /* Fetch the component */
+
+ l = priv->pending_uids;
+ priv->pending_uids = g_list_remove_link (priv->pending_uids, l);
+ priv->n_pending--;
+
+ g_assert ((priv->pending_uids && priv->n_pending != 0)
+ || (!priv->pending_uids && priv->n_pending == 0));
+
+ uid = l->data;
+ g_assert (uid != NULL);
+
+ g_list_free_1 (l);
+
+ match_component (query, uid,
+ TRUE,
+ priv->pending_total - priv->n_pending,
+ priv->pending_total);
+
+ g_free (uid);
+
+ return TRUE;
+}
+
+/* Populates the query with pending UIDs so that they can be processed
+ * asynchronously.
+ */
+static void
+populate_query (Query *query)
+{
+ QueryPrivate *priv;
+
+ priv = query->priv;
+ g_assert (priv->idle_id == 0);
+
+ priv->pending_uids = cal_backend_get_uids (priv->backend, CALOBJ_TYPE_ANY);
+ priv->pending_total = g_list_length (priv->pending_uids);
+ priv->n_pending = priv->pending_total;
+
+ priv->idle_id = g_idle_add (process_component_cb, query);
+}
+
+/* Idle handler for starting a query */
+static gboolean
+start_query_cb (gpointer data)
+{
+ Query *query;
+ QueryPrivate *priv;
+ CORBA_Environment ev;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ priv->idle_id = 0;
+
+ priv->esexp = create_sexp (query);
+
+ /* Compile the query string */
+
+ g_assert (priv->sexp != NULL);
+ e_sexp_input_text (priv->esexp, priv->sexp, strlen (priv->sexp));
+
+ if (e_sexp_parse (priv->esexp) == -1) {
+ const char *error_str;
+
+ error_str = e_sexp_error (priv->esexp);
+ g_assert (error_str != NULL);
+
+ CORBA_exception_init (&ev);
+ GNOME_Evolution_Calendar_QueryListener_notifyQueryDone (
+ priv->ql,
+ GNOME_Evolution_Calendar_QueryListener_PARSE_ERROR,
+ error_str,
+ &ev);
+
+ if (ev._major != CORBA_NO_EXCEPTION)
+ g_message ("start_query_cb(): Could not notify the listener of "
+ "a parse error");
+
+ CORBA_exception_free (&ev);
+ return FALSE;
+ }
+
+ /* Populate the query with UIDs so that we can process them asynchronously */
+
+ populate_query (query);
+
+ return FALSE;
+}
+
+/* Callback used when the backend gets loaded; we just queue the query to be
+ * started later.
+ */
+static void
+backend_opened_cb (CalBackend *backend, CalBackendOpenStatus status, gpointer data)
+{
+ Query *query;
+ QueryPrivate *priv;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ if (status == CAL_BACKEND_OPEN_SUCCESS) {
+ g_assert (cal_backend_is_loaded (backend));
+
+ priv->idle_id = g_idle_add (start_query_cb, query);
+ }
+}
+
+/* Callback used when a component changes in the backend */
+static void
+backend_obj_updated_cb (CalBackend *backend, const char *uid, gpointer data)
+{
+ Query *query;
+
+ query = QUERY (data);
+
+ match_component (query, uid, FALSE, 0, 0);
+ remove_from_pending (query, uid);
+}
+
+/* Callback used when a component is removed from the backend */
+static void
+backend_obj_removed_cb (CalBackend *backend, const char *uid, gpointer data)
+{
+ Query *query;
+ QueryPrivate *priv;
+
+ query = QUERY (data);
+ priv = query->priv;
+
+ remove_component (query, uid);
+ remove_from_pending (query, uid);
+}
+
+/**
+ * query_construct:
+ * @query: A live search query.
+ * @backend: Calendar backend that the query object will monitor.
+ * @ql: Listener for query results.
+ * @sexp: Sexp that defines the query.
+ *
+ * Constructs a #Query object by binding it to a calendar backend and a query
+ * listener. The @query object will start to populate itself asynchronously and
+ * call the listener as appropriate.
+ *
+ * Return value: The same value as @query, or NULL if the query could not
+ * be constructed.
+ **/
+Query *
+query_construct (Query *query,
+ CalBackend *backend,
+ GNOME_Evolution_Calendar_QueryListener ql,
+ const char *sexp)
+{
+ QueryPrivate *priv;
+ CORBA_Environment ev;
+
+ g_return_val_if_fail (query != NULL, NULL);
+ g_return_val_if_fail (IS_QUERY (query), NULL);
+ g_return_val_if_fail (backend != NULL, NULL);
+ g_return_val_if_fail (IS_CAL_BACKEND (backend), NULL);
+ g_return_val_if_fail (ql != CORBA_OBJECT_NIL, NULL);
+ g_return_val_if_fail (sexp != NULL, NULL);
+
+ priv = query->priv;
+
+ CORBA_exception_init (&ev);
+ priv->ql = CORBA_Object_duplicate (ql, &ev);
+ if (ev._major != CORBA_NO_EXCEPTION) {
+ g_message ("query_construct(): Could not duplicate the listener");
+ priv->ql = CORBA_OBJECT_NIL;
+ CORBA_exception_free (&ev);
+ return NULL;
+ }
+ CORBA_exception_free (&ev);
+
+ priv->backend = backend;
+ gtk_object_ref (GTK_OBJECT (priv->backend));
+
+ gtk_signal_connect (GTK_OBJECT (priv->backend), "obj_updated",
+ GTK_SIGNAL_FUNC (backend_obj_updated_cb),
+ query);
+ gtk_signal_connect (GTK_OBJECT (priv->backend), "obj_removed",
+ GTK_SIGNAL_FUNC (backend_obj_removed_cb),
+ query);
+
+ priv->sexp = g_strdup (sexp);
+
+ /* Queue the query to be started asynchronously */
+
+ if (cal_backend_is_loaded (priv->backend))
+ priv->idle_id = g_idle_add (start_query_cb, query);
+ else
+ gtk_signal_connect (GTK_OBJECT (priv->backend), "opened",
+ GTK_SIGNAL_FUNC (backend_opened_cb),
+ query);
+
+ return query;
+}
+
+Query *
+query_new (CalBackend *backend,
+ GNOME_Evolution_Calendar_QueryListener ql,
+ const char *sexp)
+{
+ Query *query;
+
+ query = QUERY (gtk_type_new (QUERY_TYPE));
+ return query_construct (query, backend, ql, sexp);
+}
diff --git a/calendar/pcs/query.h b/calendar/pcs/query.h
new file mode 100644
index 0000000000..bd10351fcb
--- /dev/null
+++ b/calendar/pcs/query.h
@@ -0,0 +1,69 @@
+/* Evolution calendar - Live search query implementation
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Author: Federico Mena-Quintero <federico@ximian.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.
+ */
+
+#ifndef QUERY_H
+#define QUERY_H
+
+#include <libgnome/gnome-defs.h>
+#include <bonobo/bonobo-xobject.h>
+#include "cal-backend.h"
+
+BEGIN_GNOME_DECLS
+
+
+
+#define QUERY_TYPE (query_get_type ())
+#define QUERY(obj) (GTK_CHECK_CAST ((obj), QUERY_TYPE, Query))
+#define QUERY_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), QUERY_TYPE, QueryClass))
+#define IS_QUERY(obj) (GTK_CHECK_TYPE ((obj), QUERY_TYPE))
+#define IS_QUERY_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), QUERY_TYPE))
+
+typedef struct _QueryPrivate QueryPrivate;
+
+typedef struct {
+ BonoboXObject xobject;
+
+ /* Private data */
+ QueryPrivate *priv;
+} Query;
+
+typedef struct {
+ BonoboXObjectClass parent_class;
+
+ POA_GNOME_Evolution_Calendar_Query__epv epv;
+} QueryClass;
+
+GtkType query_get_type (void);
+
+Query *query_construct (Query *query,
+ CalBackend *backend,
+ GNOME_Evolution_Calendar_QueryListener ql,
+ const char *sexp);
+
+Query *query_new (CalBackend *backend,
+ GNOME_Evolution_Calendar_QueryListener ql,
+ const char *sexp);
+
+
+
+END_GNOME_DECLS
+
+#endif