diff options
Diffstat (limited to 'calendar/pcs')
| -rw-r--r-- | calendar/pcs/Makefile.am | 4 | ||||
| -rw-r--r-- | calendar/pcs/cal-backend-db.c | 17 | ||||
| -rw-r--r-- | calendar/pcs/cal-backend-file.c | 31 | ||||
| -rw-r--r-- | calendar/pcs/cal-backend.c | 125 | ||||
| -rw-r--r-- | calendar/pcs/cal-backend.h | 13 | ||||
| -rw-r--r-- | calendar/pcs/cal.c | 40 | ||||
| -rw-r--r-- | calendar/pcs/query.c | 780 | ||||
| -rw-r--r-- | calendar/pcs/query.h | 69 |
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 |