This commit was manufactured by cvs2svn to create tagEVOLUTION_1_2_4

'EVOLUTION_1_2_4'.

svn path=/tags/EVOLUTION_1_2_4/; revision=20614

4 files changed, 725 insertions, 693 deletions

diff --git a/calendar/pcs/cal-backend-file.c b/calendar/pcs/cal-backend-file.c
index d11df6d076..9e67b47895 100644
--- a/calendar/pcs/cal-backend-file.c
+++ b/calendar/pcs/cal-backend-file.c
@@ -21,11 +21,9 @@
  */
 
 #include <config.h>
-#include <string.h>
-#include <unistd.h>
+#include <gtk/gtksignal.h>
 #include <bonobo/bonobo-exception.h>
 #include <bonobo/bonobo-moniker-util.h>
-#include <libgnome/gnome-i18n.h>
 #include <libgnomevfs/gnome-vfs.h>
 #include "e-util/e-dbhash.h"
 #include "cal-util/cal-recur.h"
@@ -35,11 +33,23 @@
 
 
 
+/* A category that exists in some of the objects of the calendar */
+typedef struct {
+	/* Category name, also used as the key in the categories hash table */
+	char *name;
+
+	/* Number of objects that have this category */
+	int refcount;
+} Category;
+
 /* Private part of the CalBackendFile structure */
 struct _CalBackendFilePrivate {
 	/* URI where the calendar data is stored */
 	char *uri;
 
+	/* List of Cal objects with their listeners */
+	GList *clients;
+
 	/* Toplevel VCALENDAR component */
 	icalcomponent *icalcomp;
 
@@ -59,8 +69,12 @@ struct _CalBackendFilePrivate {
 	GList *todos;
 	GList *journals;
 
+	/* Hash table of live categories, and a temporary hash of removed categories */
+	GHashTable *categories;
+	GHashTable *removed_categories;
+
 	/* Config database handle for free/busy organizer information */
-	EConfigListener *config_listener;
+	Bonobo_ConfigDatabase db;
 	
 	/* Idle handler for saving the calendar when it is dirty */
 	guint idle_id;
@@ -73,9 +87,8 @@ struct _CalBackendFilePrivate {
 
 
 static void cal_backend_file_class_init (CalBackendFileClass *class);
-static void cal_backend_file_init (CalBackendFile *cbfile, CalBackendFileClass *class);
-static void cal_backend_file_dispose (GObject *object);
-static void cal_backend_file_finalize (GObject *object);
+static void cal_backend_file_init (CalBackendFile *cbfile);
+static void cal_backend_file_destroy (GtkObject *object);
 
 static const char *cal_backend_file_get_uri (CalBackend *backend);
 static gboolean cal_backend_file_is_read_only (CalBackend *backend);
@@ -96,6 +109,7 @@ static void cal_backend_file_set_mode (CalBackend *backend, CalMode mode);
 
 static int cal_backend_file_get_n_objects (CalBackend *backend, CalObjType type);
 static char *cal_backend_file_get_default_object (CalBackend *backend, CalObjType type);
+static char *cal_backend_file_get_object (CalBackend *backend, const char *uid);
 static CalComponent *cal_backend_file_get_object_component (CalBackend *backend, const char *uid);
 static char *cal_backend_file_get_timezone_object (CalBackend *backend, const char *tzid);
 static GList *cal_backend_file_get_uids (CalBackend *backend, CalObjType type);
@@ -127,6 +141,9 @@ static icaltimezone* cal_backend_file_get_default_timezone (CalBackend *backend)
 static gboolean cal_backend_file_set_default_timezone (CalBackend *backend,
 						       const char *tzid);
 
+static void notify_categories_changed (CalBackendFile *cbfile);
+static void notify_error (CalBackendFile *cbfile, const char *message);
+
 static CalBackendClass *parent_class;
 
 
@@ -140,24 +157,24 @@ static CalBackendClass *parent_class;
  * 
  * Return value: The type ID of the #CalBackendFile class.
  **/
-GType
+GtkType
 cal_backend_file_get_type (void)
 {
-	static GType cal_backend_file_type = 0;
+	static GtkType cal_backend_file_type = 0;
 
 	if (!cal_backend_file_type) {
-		static GTypeInfo info = {
-                        sizeof (CalBackendFileClass),
-                        (GBaseInitFunc) NULL,
-                        (GBaseFinalizeFunc) NULL,
-                        (GClassInitFunc) cal_backend_file_class_init,
-                        NULL, NULL,
-                        sizeof (CalBackendFile),
-                        0,
-                        (GInstanceInitFunc) cal_backend_file_init
-                };
-		cal_backend_file_type = g_type_register_static (CAL_BACKEND_TYPE,
-								"CalBackendFile", &info, 0);
+		static const GtkTypeInfo cal_backend_file_info = {
+			"CalBackendFile",
+			sizeof (CalBackendFile),
+			sizeof (CalBackendFileClass),
+			(GtkClassInitFunc) cal_backend_file_class_init,
+			(GtkObjectInitFunc) cal_backend_file_init,
+			NULL, /* reserved_1 */
+			NULL, /* reserved_2 */
+			(GtkClassInitFunc) NULL
+		};
+
+		cal_backend_file_type = gtk_type_unique (CAL_BACKEND_TYPE, &cal_backend_file_info);
 	}
 
 	return cal_backend_file_type;
@@ -167,30 +184,30 @@ cal_backend_file_get_type (void)
 static void
 cal_backend_file_class_init (CalBackendFileClass *class)
 {
-	GObjectClass *object_class;
+	GtkObjectClass *object_class;
 	CalBackendClass *backend_class;
 
-	object_class = (GObjectClass *) class;
+	object_class = (GtkObjectClass *) class;
 	backend_class = (CalBackendClass *) class;
 
-	parent_class = (CalBackendClass *) g_type_class_peek_parent (class);
+	parent_class = gtk_type_class (CAL_BACKEND_TYPE);
 
-	object_class->dispose = cal_backend_file_dispose;
-	object_class->finalize = cal_backend_file_finalize;
+	object_class->destroy = cal_backend_file_destroy;
 
 	backend_class->get_uri = cal_backend_file_get_uri;
 	backend_class->is_read_only = cal_backend_file_is_read_only;
 	backend_class->get_cal_address = cal_backend_file_get_cal_address;
- 	backend_class->get_alarm_email_address = cal_backend_file_get_alarm_email_address;
- 	backend_class->get_ldap_attribute = cal_backend_file_get_ldap_attribute;
- 	backend_class->get_static_capabilities = cal_backend_file_get_static_capabilities;
+	backend_class->get_alarm_email_address = cal_backend_file_get_alarm_email_address;
+	backend_class->get_ldap_attribute = cal_backend_file_get_ldap_attribute;
+	backend_class->get_static_capabilities = cal_backend_file_get_static_capabilities;
 	backend_class->open = cal_backend_file_open;
 	backend_class->is_loaded = cal_backend_file_is_loaded;
 	backend_class->get_query = cal_backend_file_get_query;
 	backend_class->get_mode = cal_backend_file_get_mode;
 	backend_class->set_mode = cal_backend_file_set_mode;	
 	backend_class->get_n_objects = cal_backend_file_get_n_objects;
- 	backend_class->get_default_object = cal_backend_file_get_default_object;
+	backend_class->get_default_object = cal_backend_file_get_default_object;
+	backend_class->get_object = cal_backend_file_get_object;
 	backend_class->get_object_component = cal_backend_file_get_object_component;
 	backend_class->get_timezone_object = cal_backend_file_get_timezone_object;
 	backend_class->get_uids = cal_backend_file_get_uids;
@@ -208,9 +225,33 @@ cal_backend_file_class_init (CalBackendFileClass *class)
 	backend_class->set_default_timezone = cal_backend_file_set_default_timezone;
 }
 
+static Bonobo_ConfigDatabase
+load_db (void)
+{
+	Bonobo_ConfigDatabase db = CORBA_OBJECT_NIL;
+	CORBA_Environment ev;
+
+	CORBA_exception_init (&ev);
+ 
+	db = bonobo_get_object ("wombat:", "Bonobo/ConfigDatabase", &ev);
+	
+	if (BONOBO_EX (&ev))
+		db = CORBA_OBJECT_NIL;
+		
+	CORBA_exception_free (&ev);
+
+	return db;
+}
+
+static void
+cal_added_cb (CalBackend *backend, gpointer user_data)
+{
+	notify_categories_changed (CAL_BACKEND_FILE (backend));
+}
+
 /* Object initialization function for the file backend */
 static void
-cal_backend_file_init (CalBackendFile *cbfile, CalBackendFileClass *class)
+cal_backend_file_init (CalBackendFile *cbfile)
 {
 	CalBackendFilePrivate *priv;
 
@@ -224,10 +265,16 @@ cal_backend_file_init (CalBackendFile *cbfile, CalBackendFileClass *class)
 	priv->todos = NULL;
 	priv->journals = NULL;
 
+	priv->categories = g_hash_table_new (g_str_hash, g_str_equal);
+	priv->removed_categories = g_hash_table_new (g_str_hash, g_str_equal);
+
 	/* The timezone defaults to UTC. */
 	priv->default_zone = icaltimezone_get_utc_timezone ();
 
-	priv->config_listener = e_config_listener_new ();
+	priv->db = load_db ();
+	
+	gtk_signal_connect (GTK_OBJECT (cbfile), "cal_added",
+			    GTK_SIGNAL_FUNC (cal_added_cb), NULL);
 }
 
 /* g_hash_table_foreach() callback to destroy a CalComponent */
@@ -237,7 +284,7 @@ free_cal_component (gpointer key, gpointer value, gpointer data)
 	CalComponent *comp;
 
 	comp = CAL_COMPONENT (value);
-	g_object_unref (comp);
+	gtk_object_unref (GTK_OBJECT (comp));
 }
 
 /* Saves the calendar data */
@@ -258,13 +305,13 @@ save (CalBackendFile *cbfile)
 
 	uri = gnome_vfs_uri_new (priv->uri);
 	if (!uri)
-		goto error_malformed_uri;
+		goto error;
 
 	/* save calendar to backup file */
 	tmp = gnome_vfs_uri_to_string (uri, GNOME_VFS_URI_HIDE_NONE);
 	if (!tmp) {
 		gnome_vfs_uri_unref (uri);
-		goto error_malformed_uri;
+		goto error;
 	}
 		
 	backup_uristr = g_strconcat (tmp, "~", NULL);
@@ -275,7 +322,7 @@ save (CalBackendFile *cbfile)
 
 	if (!backup_uri) {
 		gnome_vfs_uri_unref (uri);
-		goto error_malformed_uri;
+		goto error;
 	}
 	
 	result = gnome_vfs_create_uri (&handle, backup_uri,
@@ -305,27 +352,40 @@ save (CalBackendFile *cbfile)
 		goto error;
 
 	return;
-
- error_malformed_uri:
-	cal_backend_notify_error (CAL_BACKEND (cbfile),
-				  _("Can't save calendar data: Malformed URI."));
-	return;
-
+	
  error:
-	cal_backend_notify_error (CAL_BACKEND (cbfile), gnome_vfs_result_to_string (result));
+	notify_error (cbfile, gnome_vfs_result_to_string (result));
 	return;
 }
 
-/* Dispose handler for the file backend */
+/* Used from g_hash_table_foreach(), frees a Category structure */
+static void
+free_category_cb (gpointer key, gpointer value, gpointer data)
+{
+	Category *c;
+
+	c = value;
+	g_free (c->name);
+	g_free (c);
+}
+
+/* Destroy handler for the file backend */
 static void
-cal_backend_file_dispose (GObject *object)
+cal_backend_file_destroy (GtkObject *object)
 {
 	CalBackendFile *cbfile;
 	CalBackendFilePrivate *priv;
+	GList *clients;
+
+	g_return_if_fail (object != NULL);
+	g_return_if_fail (IS_CAL_BACKEND_FILE (object));
 
 	cbfile = CAL_BACKEND_FILE (object);
 	priv = cbfile->priv;
 
+	clients = CAL_BACKEND (cbfile)->clients;
+	g_assert (clients == NULL);
+
 	/* Save if necessary */
 
 	if (priv->idle_id != 0) {
@@ -334,6 +394,13 @@ cal_backend_file_dispose (GObject *object)
 		priv->idle_id = 0;
 	}
 
+	/* Clean up */
+
+	if (priv->uri) {
+	        g_free (priv->uri);
+		priv->uri = NULL;
+	}
+
 	if (priv->comp_uid_hash) {
 		g_hash_table_foreach (priv->comp_uid_hash, 
 				      free_cal_component, NULL);
@@ -348,45 +415,27 @@ cal_backend_file_dispose (GObject *object)
 	priv->todos = NULL;
 	priv->journals = NULL;
 
+	g_hash_table_foreach (priv->categories, free_category_cb, NULL);
+	g_hash_table_destroy (priv->categories);
+	priv->categories = NULL;
+
+	g_hash_table_foreach (priv->removed_categories, free_category_cb, NULL);
+	g_hash_table_destroy (priv->removed_categories);
+	priv->removed_categories = NULL;
+
 	if (priv->icalcomp) {
 		icalcomponent_free (priv->icalcomp);
 		priv->icalcomp = NULL;
 	}
 
-	if (priv->config_listener) {
-		g_object_unref (priv->config_listener);
-		priv->config_listener = NULL;
-	}
-
-	if (G_OBJECT_CLASS (parent_class)->dispose)
-		(* G_OBJECT_CLASS (parent_class)->dispose) (object);
-}
-
-/* Finalize handler for the file backend */
-static void
-cal_backend_file_finalize (GObject *object)
-{
-	CalBackendFile *cbfile;
-	CalBackendFilePrivate *priv;
-
-	g_return_if_fail (object != NULL);
-	g_return_if_fail (IS_CAL_BACKEND_FILE (object));
-
-	cbfile = CAL_BACKEND_FILE (object);
-	priv = cbfile->priv;
-
-	/* Clean up */
-
-	if (priv->uri) {
-	        g_free (priv->uri);
-		priv->uri = NULL;
-	}
-
+	bonobo_object_release_unref (priv->db, NULL);
+	priv->db = CORBA_OBJECT_NIL;
+	
 	g_free (priv);
 	cbfile->priv = NULL;
 
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+	if (GTK_OBJECT_CLASS (parent_class)->destroy)
+		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 }
 
 
@@ -444,24 +493,71 @@ cal_backend_file_get_cal_address (CalBackend *backend)
 }
 
 static const char *
-cal_backend_file_get_ldap_attribute (CalBackend *backend)
+cal_backend_file_get_alarm_email_address (CalBackend *backend)
 {
+	/* A file backend has no particular email address associated
+	 * with it (although that would be a useful feature some day).
+	 */
 	return NULL;
 }
 
 static const char *
-cal_backend_file_get_alarm_email_address (CalBackend *backend)
+cal_backend_file_get_ldap_attribute (CalBackend *backend)
 {
- 	/* A file backend has no particular email address associated
- 	 * with it (although that would be a useful feature some day).
- 	 */
 	return NULL;
 }
 
 static const char *
 cal_backend_file_get_static_capabilities (CalBackend *backend)
 {
- 	return "no-email-alarms";
+	return "no-email-alarms";
+}
+
+/* Used from g_hash_table_foreach(), adds a category name to the sequence */
+static void
+add_category_cb (gpointer key, gpointer value, gpointer data)
+{
+	Category *c;
+	GNOME_Evolution_Calendar_StringSeq *seq;
+
+	c = value;
+	seq = data;
+
+	seq->_buffer[seq->_length] = CORBA_string_dup (c->name);
+	seq->_length++;
+}
+
+/* Notifies the clients with the current list of categories */
+static void
+notify_categories_changed (CalBackendFile *cbfile)
+{
+	CalBackendFilePrivate *priv;
+	GNOME_Evolution_Calendar_StringSeq *seq;
+	GList *l;
+
+	priv = cbfile->priv;
+
+	/* Build the sequence of category names */
+
+	seq = GNOME_Evolution_Calendar_StringSeq__alloc ();
+	seq->_length = 0;
+	seq->_maximum = g_hash_table_size (priv->categories);
+	seq->_buffer = CORBA_sequence_CORBA_string_allocbuf (seq->_maximum);
+	CORBA_sequence_set_release (seq, TRUE);
+
+	g_hash_table_foreach (priv->categories, add_category_cb, seq);
+	g_assert (seq->_length == seq->_maximum);
+
+	/* Notify the clients */
+
+	for (l = CAL_BACKEND (cbfile)->clients; l; l = l->next) {
+		Cal *cal;
+
+		cal = CAL (l->data);
+		cal_notify_categories_changed (cal, seq);
+	}
+
+	CORBA_free (seq);
 }
 
 /* Idle handler; we save the calendar since it is dirty */
@@ -526,6 +622,68 @@ check_dup_uid (CalBackendFile *cbfile, CalComponent *comp)
 	mark_dirty (cbfile);
 }
 
+/* Updates the hash table of categories by adding or removing those in the
+ * component.
+ */
+static void
+update_categories_from_comp (CalBackendFile *cbfile, CalComponent *comp, gboolean add)
+{
+	CalBackendFilePrivate *priv;
+	GSList *categories, *l;
+
+	priv = cbfile->priv;
+
+	cal_component_get_categories_list (comp, &categories);
+
+	for (l = categories; l; l = l->next) {
+		const char *name;
+		Category *c;
+
+		name = l->data;
+		c = g_hash_table_lookup (priv->categories, name);
+
+		if (add) {
+			/* Add the category to the set */
+			if (c)
+				c->refcount++;
+			else {
+				/* See if it was in the removed categories */
+
+				c = g_hash_table_lookup (priv->removed_categories, name);
+				if (c) {
+					/* Move it to the set of live categories */
+					g_assert (c->refcount == 0);
+					g_hash_table_remove (priv->removed_categories, c->name);
+
+					c->refcount = 1;
+					g_hash_table_insert (priv->categories, c->name, c);
+				} else {
+					/* Create a new category */
+					c = g_new (Category, 1);
+					c->name = g_strdup (name);
+					c->refcount = 1;
+
+					g_hash_table_insert (priv->categories, c->name, c);
+				}
+			}
+		} else {
+			/* Remove the category from the set --- it *must* have existed */
+
+			g_assert (c != NULL);
+			g_assert (c->refcount > 0);
+
+			c->refcount--;
+
+			if (c->refcount == 0) {
+				g_hash_table_remove (priv->categories, c->name);
+				g_hash_table_insert (priv->removed_categories, c->name, c);
+			}
+		}
+	}
+
+	cal_component_free_categories_list (categories);
+}
+
 /* Tries to add an icalcomponent to the file backend.  We only store the objects
  * of the types we support; all others just remain in the toplevel component so
  * that we don't lose them.
@@ -536,7 +694,6 @@ add_component (CalBackendFile *cbfile, CalComponent *comp, gboolean add_to_tople
 	CalBackendFilePrivate *priv;
 	GList **list;
 	const char *uid;
-	GSList *categories;
 
 	priv = cbfile->priv;
 
@@ -579,9 +736,8 @@ add_component (CalBackendFile *cbfile, CalComponent *comp, gboolean add_to_tople
 	}
 
 	/* Update the set of categories */
-	cal_component_get_categories_list (comp, &categories);
-	cal_backend_ref_categories (CAL_BACKEND (cbfile), categories);
-	cal_component_free_categories_list (categories);
+
+	update_categories_from_comp (cbfile, comp, TRUE);
 }
 
 /* Removes a component from the backend's hash and lists.  Does not perform
@@ -595,7 +751,6 @@ remove_component (CalBackendFile *cbfile, CalComponent *comp)
 	icalcomponent *icalcomp;
 	const char *uid;
 	GList **list, *l;
-	GSList *categories;
 
 	priv = cbfile->priv;
 
@@ -637,11 +792,10 @@ remove_component (CalBackendFile *cbfile, CalComponent *comp)
 	g_list_free_1 (l);
 
 	/* Update the set of categories */
-	cal_component_get_categories_list (comp, &categories);
-	cal_backend_unref_categories (CAL_BACKEND (cbfile), categories);
-	cal_component_free_categories_list (categories);
 
-	g_object_unref (comp);
+	update_categories_from_comp (cbfile, comp, FALSE);
+
+	gtk_object_unref (GTK_OBJECT (comp));
 }
 
 /* Scans the toplevel VCALENDAR component and stores the objects it finds */
@@ -680,19 +834,53 @@ scan_vcalendar (CalBackendFile *cbfile)
 	}
 }
 
+/* Callback used from icalparser_parse() */
+static char *
+get_line_fn (char *s, size_t size, void *data)
+{
+	FILE *file;
+
+	file = data;
+	return fgets (s, size, file);
+}
+
+/* Parses an open iCalendar file and returns a toplevel component with the contents */
+static icalcomponent *
+parse_file (FILE *file)
+{
+	icalparser *parser;
+	icalcomponent *icalcomp;
+
+	parser = icalparser_new ();
+	icalparser_set_gen_data (parser, file);
+
+	icalcomp = icalparser_parse (parser, get_line_fn);
+	icalparser_free (parser);
+
+	return icalcomp;
+}
+
 /* Parses an open iCalendar file and loads it into the backend */
 static CalBackendOpenStatus
-open_cal (CalBackendFile *cbfile, const char *uristr)
+open_cal (CalBackendFile *cbfile, const char *uristr, FILE *file)
 {
 	CalBackendFilePrivate *priv;
 	icalcomponent *icalcomp;
 
 	priv = cbfile->priv;
 
-	icalcomp = cal_util_parse_ics_file (uristr);
-	if (!icalcomp)
+	icalcomp = parse_file (file);
+
+	if (fclose (file) != 0) {
+		if (icalcomp)
+			icalcomponent_free (icalcomp);
+
 		return CAL_BACKEND_OPEN_ERROR;
+	}
 
+	if (!icalcomp)
+		return CAL_BACKEND_OPEN_ERROR;
+		
 	/* FIXME: should we try to demangle XROOT components and
 	 * individual components as well?
 	 */
@@ -738,6 +926,7 @@ cal_backend_file_open (CalBackend *backend, const char *uristr, gboolean only_if
 {
 	CalBackendFile *cbfile;
 	CalBackendFilePrivate *priv;
+	FILE *file;
 	char *str_uri;
 	GnomeVFSURI *uri;
 	CalBackendOpenStatus status;
@@ -772,8 +961,11 @@ cal_backend_file_open (CalBackend *backend, const char *uristr, gboolean only_if
 		return CAL_BACKEND_OPEN_ERROR;
 	}
 
-	if (access (str_uri, R_OK) == 0)
-		status = open_cal (cbfile, str_uri);
+	/* Load! */
+	file = fopen (str_uri, "r");
+
+	if (file)
+		status = open_cal (cbfile, str_uri, file);
 	else {
 		if (only_if_exists)
 			status = CAL_BACKEND_OPEN_NOT_FOUND;
@@ -826,13 +1018,31 @@ cal_backend_file_get_mode (CalBackend *backend)
 	return CAL_MODE_LOCAL;	
 }
 
+static void
+notify_mode (CalBackendFile *cbfile, 
+	     GNOME_Evolution_Calendar_Listener_SetModeStatus status, 
+	     GNOME_Evolution_Calendar_CalMode mode)
+{
+	CalBackendFilePrivate *priv;
+	GList *l;
+
+	priv = cbfile->priv;
+
+	for (l = CAL_BACKEND (cbfile)->clients; l; l = l->next) {
+		Cal *cal;
+
+		cal = CAL (l->data);
+		cal_notify_mode (cal, status, mode);
+	}
+}
+
 /* Set_mode handler for the file backend */
 static void
 cal_backend_file_set_mode (CalBackend *backend, CalMode mode)
 {
-	cal_backend_notify_mode (backend,
-				 GNOME_Evolution_Calendar_Listener_MODE_NOT_SUPPORTED,
-				 GNOME_Evolution_Calendar_MODE_LOCAL);
+	notify_mode (CAL_BACKEND_FILE (backend),
+		     GNOME_Evolution_Calendar_Listener_MODE_NOT_SUPPORTED,
+		     GNOME_Evolution_Calendar_MODE_LOCAL);
 	
 }
 
@@ -863,41 +1073,66 @@ cal_backend_file_get_n_objects (CalBackend *backend, CalObjType type)
 	return n;
 }
 
+/* Get_object handler for the file backend */
 static char *
 cal_backend_file_get_default_object (CalBackend *backend, CalObjType type)
 {
- 	CalBackendFile *cbfile;
- 	CalBackendFilePrivate *priv;
- 	CalComponent *comp;
- 	char *calobj;
- 	
- 	cbfile = CAL_BACKEND_FILE (backend);
- 	priv = cbfile->priv;
- 
- 	comp = cal_component_new ();
- 	
- 	switch (type) {
- 	case CALOBJ_TYPE_EVENT:
- 		cal_component_set_new_vtype (comp, CAL_COMPONENT_EVENT);
- 		break;
- 	case CALOBJ_TYPE_TODO:
- 		cal_component_set_new_vtype (comp, CAL_COMPONENT_TODO);
- 		break;
- 	case CALOBJ_TYPE_JOURNAL:
- 		cal_component_set_new_vtype (comp, CAL_COMPONENT_JOURNAL);
- 		break;
- 	default:
- 		g_object_unref (comp);
- 		return NULL;
- 	}
- 	
- 	calobj = cal_component_get_as_string (comp);
- 	g_object_unref (comp);
- 
- 	return calobj;
+	CalBackendFile *cbfile;
+	CalBackendFilePrivate *priv;
+	CalComponent *comp;
+	char *calobj;
+	
+	cbfile = CAL_BACKEND_FILE (backend);
+	priv = cbfile->priv;
+
+	comp = cal_component_new ();
+	
+	switch (type) {
+	case CALOBJ_TYPE_EVENT:
+		cal_component_set_new_vtype (comp, CAL_COMPONENT_EVENT);
+		break;
+	case CALOBJ_TYPE_TODO:
+		cal_component_set_new_vtype (comp, CAL_COMPONENT_TODO);
+		break;
+	case CALOBJ_TYPE_JOURNAL:
+		cal_component_set_new_vtype (comp, CAL_COMPONENT_JOURNAL);
+		break;
+	default:
+		gtk_object_unref (GTK_OBJECT (comp));
+		return NULL;
+	}
+	
+	calobj = cal_component_get_as_string (comp);
+	gtk_object_unref (GTK_OBJECT (comp));
+
+	return calobj;
 }
 
-/* Get_object_component handler for the file backend */
+/* Get_object handler for the file backend */
+static char *
+cal_backend_file_get_object (CalBackend *backend, const char *uid)
+{
+	CalBackendFile *cbfile;
+	CalBackendFilePrivate *priv;
+	CalComponent *comp;
+
+	cbfile = CAL_BACKEND_FILE (backend);
+	priv = cbfile->priv;
+
+	g_return_val_if_fail (uid != NULL, NULL);
+
+	g_return_val_if_fail (priv->icalcomp != NULL, NULL);
+	g_assert (priv->comp_uid_hash != NULL);
+
+	comp = lookup_component (cbfile, uid);
+
+	if (!comp)
+		return NULL;
+
+	return cal_component_get_as_string (comp);
+}
+
+/* Get_object handler for the file backend */
 static CalComponent *
 cal_backend_file_get_object_component (CalBackend *backend, const char *uid)
 {
@@ -915,7 +1150,7 @@ cal_backend_file_get_object_component (CalBackend *backend, const char *uid)
 	return lookup_component (cbfile, uid);
 }
 
-/* Get_timezone_object handler for the file backend */
+/* Get_object handler for the file backend */
 static char *
 cal_backend_file_get_timezone_object (CalBackend *backend, const char *tzid)
 {
@@ -1238,7 +1473,7 @@ cal_backend_file_get_free_busy (CalBackend *backend, GList *users, time_t start,
 	g_return_val_if_fail (start <= end, NULL);
 
 	if (users == NULL) {
-		if (cal_backend_mail_account_get_default (priv->config_listener, &address, &name)) {
+		if (cal_backend_mail_account_get_default (priv->db, &address, &name)) {			
 			vfb = create_user_free_busy (cbfile, address, name, start, end);
 			calobj = icalcomponent_as_ical_string (vfb);
 			obj_list = g_list_append (obj_list, g_strdup (calobj));
@@ -1249,7 +1484,7 @@ cal_backend_file_get_free_busy (CalBackend *backend, GList *users, time_t start,
 	} else {
 		for (l = users; l != NULL; l = l->next ) {
 			address = l->data;			
-			if (cal_backend_mail_account_is_valid (priv->config_listener, address, &name)) {
+			if (cal_backend_mail_account_is_valid (priv->db, address, &name)) {
 				vfb = create_user_free_busy (cbfile, address, name, start, end);
 				calobj = icalcomponent_as_ical_string (vfb);
 				obj_list = g_list_append (obj_list, g_strdup (calobj));
@@ -1297,7 +1532,7 @@ cal_backend_file_compute_changes_foreach_key (const char *key, gpointer data)
 		be_data->change_ids = g_list_prepend (be_data->change_ids, g_strdup (key));
 
 		g_free (calobj);
-		g_object_unref (comp);
+		gtk_object_unref (GTK_OBJECT (comp));
  	}
 }
 
@@ -1520,6 +1755,88 @@ cal_backend_file_get_alarms_for_object (CalBackend *backend, const char *uid,
 	return corba_alarms;
 }
 
+/* Notifies a backend's clients that an object was updated */
+static void
+notify_update (CalBackendFile *cbfile, const char *uid)
+{
+	CalBackendFilePrivate *priv;
+	GList *l;
+
+	priv = cbfile->priv;
+
+	cal_backend_obj_updated (CAL_BACKEND (cbfile), uid);
+
+	for (l = CAL_BACKEND (cbfile)->clients; l; l = l->next) {
+		Cal *cal;
+
+		cal = CAL (l->data);
+		cal_notify_update (cal, uid);
+	}
+}
+
+/* Notifies a backend's clients that an object was removed */
+static void
+notify_remove (CalBackendFile *cbfile, const char *uid)
+{
+	CalBackendFilePrivate *priv;
+	GList *l;
+
+	priv = cbfile->priv;
+
+	cal_backend_obj_removed (CAL_BACKEND (cbfile), uid);
+
+	for (l = CAL_BACKEND (cbfile)->clients; l; l = l->next) {
+		Cal *cal;
+
+		cal = CAL (l->data);
+		cal_notify_remove (cal, uid);
+	}
+}
+
+/* Notifies a backend's clients that an error has occurred */
+static void
+notify_error (CalBackendFile *cbfile, const char *message)
+{
+	CalBackendFilePrivate *priv;
+	GList *l;
+
+	priv = cbfile->priv;
+
+	for (l = CAL_BACKEND (cbfile)->clients; l; l = l->next) {
+		Cal *cal;
+
+		cal = CAL (l->data);
+		cal_notify_error (cal, message);
+	}
+}
+
+/* Used from g_hash_table_foreach_remove(); removes and frees a category */
+static gboolean
+remove_category_cb (gpointer key, gpointer value, gpointer data)
+{
+	Category *c;
+
+	c = value;
+	g_free (c->name);
+	g_free (c);
+
+	return TRUE;
+}
+
+/* Clears the table of removed categories */
+static void
+clean_removed_categories (CalBackendFile *cbfile)
+{
+	CalBackendFilePrivate *priv;
+
+	priv = cbfile->priv;
+
+	g_hash_table_foreach_remove (priv->removed_categories,
+				     remove_category_cb,
+				     NULL);
+}
+
+
 /* Creates a CalComponent for the given icalcomponent and adds it to our
    cache. Note that the icalcomponent is not added to the toplevel
    icalcomponent here. That needs to be done elsewhere. It returns the uid
@@ -1536,14 +1853,14 @@ cal_backend_file_update_object (CalBackendFile *cbfile,
 	/* Create a CalComponent wrapper for the icalcomponent. */
 	comp = cal_component_new ();
 	if (!cal_component_set_icalcomponent (comp, icalcomp)) {
-		g_object_unref (comp);
+		gtk_object_unref (GTK_OBJECT (comp));
 		return NULL;
 	}
 
 	/* Get the UID, and check it isn't empty. */
 	cal_component_get_uid (comp, &comp_uid);
 	if (!comp_uid || !comp_uid[0]) {
-		g_object_unref (comp);
+		gtk_object_unref (GTK_OBJECT (comp));
 		return NULL;
 	}
 
@@ -1599,6 +1916,7 @@ cal_backend_file_update_objects (CalBackend *backend, const char *calobj, CalObj
 	icalcomponent *toplevel_comp, *icalcomp = NULL;
 	icalcomponent_kind kind;
 	icalproperty_method method;
+	int old_n_categories, new_n_categories;
 	icalcomponent *subcomp;
 	CalBackendResult retval = CAL_BACKEND_RESULT_SUCCESS;
 	GList *updated_uids = NULL, *removed_uids = NULL, *elem;
@@ -1635,6 +1953,13 @@ cal_backend_file_update_objects (CalBackend *backend, const char *calobj, CalObj
 
 	method = icalcomponent_get_method (toplevel_comp);
 
+	/* The list of removed categories must be empty because we are about to
+	 * start a new scanning process.
+	 */
+	g_assert (g_hash_table_size (priv->removed_categories) == 0);
+
+	old_n_categories = g_hash_table_size (priv->categories);
+
 	/* Step throught the VEVENT/VTODOs being added, create CalComponents
 	   for them, and add them to our cache. */
 	subcomp = icalcomponent_get_first_component (toplevel_comp,
@@ -1672,6 +1997,8 @@ cal_backend_file_update_objects (CalBackend *backend, const char *calobj, CalObj
 	   resolving any conflicting TZIDs. */
 	icalcomponent_merge_component (priv->icalcomp, toplevel_comp);
 
+	new_n_categories = g_hash_table_size (priv->categories);
+
 	mark_dirty (cbfile);
 
 	/* Now emit notification signals for all of the added components.
@@ -1679,18 +2006,24 @@ cal_backend_file_update_objects (CalBackend *backend, const char *calobj, CalObj
 	   stable state before emitting signals. */
 	for (elem = updated_uids; elem; elem = elem->next) {
 		char *comp_uid = elem->data;
-		cal_backend_notify_update (backend, comp_uid);
+		notify_update (cbfile, comp_uid);
 		g_free (comp_uid);
 	}
 	g_list_free (updated_uids);
 
 	for (elem = removed_uids; elem; elem = elem->next) {
 		char *comp_uid = elem->data;
-		cal_backend_notify_remove (backend, comp_uid);
+		notify_remove (cbfile, comp_uid);
 		g_free (comp_uid);
 	}
 	g_list_free (removed_uids);
 
+	if (old_n_categories != new_n_categories ||
+	    g_hash_table_size (priv->removed_categories) != 0) {
+		clean_removed_categories (cbfile);
+		notify_categories_changed (cbfile);
+	}
+
 	return retval;
 }
 
@@ -1714,11 +2047,21 @@ cal_backend_file_remove_object (CalBackend *backend, const char *uid, CalObjModT
 	if (!comp)
 		return CAL_BACKEND_RESULT_NOT_FOUND;
 
+	/* The list of removed categories must be empty because we are about to
+	 * start a new scanning process.
+	 */
+	g_assert (g_hash_table_size (priv->removed_categories) == 0);
+
 	remove_component (cbfile, comp);
 
 	mark_dirty (cbfile);
 
-	cal_backend_notify_remove (backend, uid);
+	notify_remove (cbfile, uid);
+
+	if (g_hash_table_size (priv->removed_categories) != 0) {
+		clean_removed_categories (cbfile);
+		notify_categories_changed (cbfile);
+	}
 
 	return CAL_BACKEND_RESULT_SUCCESS;
 }
diff --git a/calendar/pcs/cal-backend.c b/calendar/pcs/cal-backend.c
index 765d873f79..e074f09bc2 100644
--- a/calendar/pcs/cal-backend.c
+++ b/calendar/pcs/cal-backend.c
@@ -23,38 +23,17 @@
  */
 
 #include <config.h>
-#include <libxml/parser.h>
-#include <libxml/parserInternals.h>
-#include <libxml/xmlmemory.h>
+#include <gtk/gtkobject.h>
+#include <gtk/gtksignal.h>
+#include <gnome-xml/parser.h>
+#include <gnome-xml/parserInternals.h>
+#include <gnome-xml/xmlmemory.h>
 
 #include "cal-backend.h"
 #include "libversit/vcc.h"
 
 
 
-/* A category that exists in some of the objects of the calendar */
-typedef struct {
-	/* Category name, also used as the key in the categories hash table */
-	char *name;
-
-	/* Number of objects that have this category */
-	int refcount;
-} CalBackendCategory;
-
-/* Private part of the CalBackend structure */
-struct _CalBackendPrivate {
-	/* List of Cal objects with their listeners */
-	GList *clients;
-
-	/* Hash table of live categories, temporary hash of
-	 * added/removed categories, and idle handler for sending
-	 * category_changed.
-	 */
-	GHashTable *categories;
-	GHashTable *changed_categories;
-	guint category_idle_id;
-};
-
 /* Signal IDs */
 enum {
 	LAST_CLIENT_GONE,
@@ -64,19 +43,12 @@ enum {
 	OBJ_REMOVED,
 	LAST_SIGNAL
 };
-static guint cal_backend_signals[LAST_SIGNAL];
 
 static void cal_backend_class_init (CalBackendClass *class);
-static void cal_backend_init (CalBackend *backend);
-static void cal_backend_finalize (GObject *object);
-
-static char *get_object (CalBackend *backend, const char *uid);
-
-static void notify_categories_changed (CalBackend *backend);
 
-#define CLASS(backend) (CAL_BACKEND_CLASS (G_OBJECT_GET_CLASS (backend)))
+static guint cal_backend_signals[LAST_SIGNAL];
 
-static GObjectClass *parent_class;
+#define CLASS(backend) (CAL_BACKEND_CLASS (GTK_OBJECT (backend)->klass))
 
 
 
@@ -89,23 +61,25 @@ static GObjectClass *parent_class;
  *
  * Return value: The type ID of the #CalBackend class.
  **/
-GType
+GtkType
 cal_backend_get_type (void)
 {
-	static GType cal_backend_type = 0;
+	static GtkType cal_backend_type = 0;
 
 	if (!cal_backend_type) {
-		static GTypeInfo info = {
-                        sizeof (CalBackendClass),
-                        (GBaseInitFunc) NULL,
-                        (GBaseFinalizeFunc) NULL,
-                        (GClassInitFunc) cal_backend_class_init,
-                        NULL, NULL,
-                        sizeof (CalBackend),
-                        0,
-                        (GInstanceInitFunc) cal_backend_init,
-                };
-		cal_backend_type = g_type_register_static (G_TYPE_OBJECT, "CalBackend", &info, 0);
+		static const GtkTypeInfo cal_backend_info = {
+			"CalBackend",
+			sizeof (CalBackend),
+			sizeof (CalBackendClass),
+			(GtkClassInitFunc) cal_backend_class_init,
+			(GtkObjectInitFunc) NULL,
+			NULL, /* reserved_1 */
+			NULL, /* reserved_2 */
+			(GtkClassInitFunc) NULL
+		};
+
+		cal_backend_type =
+			gtk_type_unique (GTK_TYPE_OBJECT, &cal_backend_info);
 	}
 
 	return cal_backend_type;
@@ -115,58 +89,51 @@ cal_backend_get_type (void)
 static void
 cal_backend_class_init (CalBackendClass *class)
 {
-	GObjectClass *object_class;
-
-	parent_class = (GObjectClass *) g_type_class_peek_parent (class);
+	GtkObjectClass *object_class;
 
-	object_class = (GObjectClass *) class;
+	object_class = (GtkObjectClass *) class;
 
 	cal_backend_signals[LAST_CLIENT_GONE] =
-		g_signal_new ("last_client_gone",
-			      G_TYPE_FROM_CLASS (class),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalBackendClass, last_client_gone),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__VOID,
-			      G_TYPE_NONE, 0);
+		gtk_signal_new ("last_client_gone",
+				GTK_RUN_FIRST,
+				object_class->type,
+				GTK_SIGNAL_OFFSET (CalBackendClass, last_client_gone),
+				gtk_marshal_NONE__NONE,
+				GTK_TYPE_NONE, 0);
 	cal_backend_signals[CAL_ADDED] =
-		g_signal_new ("cal_added",
-			      G_TYPE_FROM_CLASS (class),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalBackendClass, cal_added),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__POINTER,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_POINTER);
+		gtk_signal_new ("cal_added",
+				GTK_RUN_FIRST,
+				object_class->type,
+				GTK_SIGNAL_OFFSET (CalBackendClass, cal_added),
+				gtk_marshal_NONE__POINTER,
+				GTK_TYPE_NONE, 1,
+				GTK_TYPE_POINTER);
 	cal_backend_signals[OPENED] =
-		g_signal_new ("opened",
-			      G_TYPE_FROM_CLASS (class),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalBackendClass, opened),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__ENUM,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_ENUM);
+		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] =
-		g_signal_new ("obj_updated",
-			      G_TYPE_FROM_CLASS (class),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalBackendClass, obj_updated),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
+		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] =
-		g_signal_new ("obj_removed",
-			      G_TYPE_FROM_CLASS (class),
-			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (CalBackendClass, obj_removed),
-			      NULL, NULL,
-			      g_cclosure_marshal_VOID__STRING,
-			      G_TYPE_NONE, 1,
-			      G_TYPE_STRING);
+		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);
 
-	object_class->finalize = cal_backend_finalize;
+	gtk_object_class_add_signals (object_class, cal_backend_signals, LAST_SIGNAL);
 
 	class->last_client_gone = NULL;
 	class->opened = NULL;
@@ -184,7 +151,7 @@ cal_backend_class_init (CalBackendClass *class)
 	class->get_mode = NULL;
 	class->set_mode = NULL;	
 	class->get_n_objects = NULL;
-	class->get_object = get_object;
+	class->get_object = NULL;
 	class->get_object_component = NULL;
 	class->get_timezone_object = NULL;
 	class->get_uids = NULL;
@@ -198,51 +165,6 @@ cal_backend_class_init (CalBackendClass *class)
 	class->send_object = NULL;
 }
 
-/* Object initialization func for the calendar backend */
-void
-cal_backend_init (CalBackend *backend)
-{
-	CalBackendPrivate *priv;
-
-	priv = g_new0 (CalBackendPrivate, 1);
-	backend->priv = priv;
-
-	priv->categories = g_hash_table_new (g_str_hash, g_str_equal);
-	priv->changed_categories = g_hash_table_new (g_str_hash, g_str_equal);
-}
-
-/* Used from g_hash_table_foreach(), frees a CalBackendCategory structure */
-static void
-free_category_cb (gpointer key, gpointer value, gpointer data)
-{
-	CalBackendCategory *c = value;
-
-	g_free (c->name);
-	g_free (c);
-}
-
-void
-cal_backend_finalize (GObject *object)
-{
-	CalBackend *backend = (CalBackend *)object;
-	CalBackendPrivate *priv;
-
-	priv = backend->priv;
-
-	g_assert (priv->clients == NULL);
-
-	g_hash_table_foreach (priv->categories, free_category_cb, NULL);
-	g_hash_table_destroy (priv->categories);
-
-	g_hash_table_foreach (priv->changed_categories, free_category_cb, NULL);
-	g_hash_table_destroy (priv->changed_categories);
-
-	if (priv->category_idle_id)
-		g_source_remove (priv->category_idle_id);
-
-	G_OBJECT_CLASS (parent_class)->finalize (object);
-}
-
 
 
 /**
@@ -315,17 +237,37 @@ cal_backend_get_static_capabilities (CalBackend *backend)
 
 /* Callback used when a Cal is destroyed */
 static void
-cal_destroy_cb (gpointer data, GObject *where_cal_was)
+cal_destroy_cb (GtkObject *object, gpointer data)
 {
-	CalBackend *backend = CAL_BACKEND (data);
-	CalBackendPrivate *priv = backend->priv;
+	Cal *cal;
+	Cal *lcal;
+	CalBackend *backend;
+	GList *l;
+
+	cal = CAL (object);
+
+	backend = CAL_BACKEND (data);
+
+	/* Find the cal in the list of clients */
 
-	priv->clients = g_list_remove (priv->clients, where_cal_was);
+	for (l = backend->clients; l; l = l->next) {
+		lcal = CAL (l->data);
+
+		if (lcal == cal)
+			break;
+	}
+
+	g_assert (l != NULL);
+
+	/* Disconnect */
+
+	backend->clients = g_list_remove_link (backend->clients, l);
+	g_list_free_1 (l);
 
 	/* When all clients go away, notify the parent factory about it so that
 	 * it may decide whether to kill the backend or not.
 	 */
-	if (!priv->clients)
+	if (!backend->clients)
 		cal_backend_last_client_gone (backend);
 }
 
@@ -340,25 +282,22 @@ cal_destroy_cb (gpointer data, GObject *where_cal_was)
 void
 cal_backend_add_cal (CalBackend *backend, Cal *cal)
 {
-	CalBackendPrivate *priv = backend->priv;
-
 	g_return_if_fail (backend != NULL);
 	g_return_if_fail (IS_CAL_BACKEND (backend));
 	g_return_if_fail (IS_CAL (cal));
 
-	/* we do not keep a (strong) reference to the Cal since the
-	 * Calendar user agent owns it */
-	g_object_weak_ref (G_OBJECT (cal), cal_destroy_cb, backend);
+	/* we do not keep a reference to the Cal since the Calendar
+	 * user agent owns it */
+	gtk_signal_connect (GTK_OBJECT (cal), "destroy",
+			    GTK_SIGNAL_FUNC (cal_destroy_cb),
+			    backend);
 
-	priv->clients = g_list_prepend (priv->clients, cal);
-
-	/* Tell the new client about the list of categories.
-	 * (Ends up telling all the other clients too, but *shrug*.)
-	 */
-	notify_categories_changed (backend);
+	backend->clients = g_list_prepend (backend->clients, cal);
 
 	/* notify backend that a new Cal has been added */
-	g_signal_emit (backend, cal_backend_signals[CAL_ADDED], 0, cal);
+	gtk_signal_emit (GTK_OBJECT (backend),
+			 cal_backend_signals[CAL_ADDED],
+			 cal);
 }
 
 /**
@@ -520,19 +459,6 @@ cal_backend_get_n_objects (CalBackend *backend, CalObjType type)
 	return (* CLASS (backend)->get_n_objects) (backend, type);
 }
 
-/* Default cal_backend_get_object implementation */
-static char *
-get_object (CalBackend *backend, const char *uid)
-{
-	CalComponent *comp;
-
-	comp = cal_backend_get_object_component (backend, uid);
-	if (!comp)
-		return NULL;
-
-	return cal_component_get_as_string (comp);
-}
-
 char *
 cal_backend_get_default_object (CalBackend *backend, CalObjType type)
 {
@@ -894,7 +820,7 @@ cal_backend_last_client_gone (CalBackend *backend)
 	g_return_if_fail (backend != NULL);
 	g_return_if_fail (IS_CAL_BACKEND (backend));
 
-	g_signal_emit (G_OBJECT (backend), cal_backend_signals[LAST_CLIENT_GONE], 0);
+	gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[LAST_CLIENT_GONE]);
 }
 
 /**
@@ -911,8 +837,8 @@ cal_backend_opened (CalBackend *backend, CalBackendOpenStatus status)
 	g_return_if_fail (backend != NULL);
 	g_return_if_fail (IS_CAL_BACKEND (backend));
 
-	g_signal_emit (G_OBJECT (backend), cal_backend_signals[OPENED],
-		       0, status);
+	gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OPENED],
+			 status);
 }
 
 /**
@@ -930,8 +856,8 @@ cal_backend_obj_updated (CalBackend *backend, const char *uid)
 	g_return_if_fail (IS_CAL_BACKEND (backend));
 	g_return_if_fail (uid != NULL);
 
-	g_signal_emit (G_OBJECT (backend), cal_backend_signals[OBJ_UPDATED],
-		       0, uid);
+	gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OBJ_UPDATED],
+			 uid);
 }
 
 /**
@@ -949,8 +875,8 @@ cal_backend_obj_removed (CalBackend *backend, const char *uid)
 	g_return_if_fail (IS_CAL_BACKEND (backend));
 	g_return_if_fail (uid != NULL);
 
-	g_signal_emit (G_OBJECT (backend), cal_backend_signals[OBJ_REMOVED],
-		       0, uid);
+	gtk_signal_emit (GTK_OBJECT (backend), cal_backend_signals[OBJ_REMOVED],
+			 uid);
 }
 
 
@@ -1019,228 +945,3 @@ cal_backend_set_default_timezone (CalBackend *backend, const char *tzid)
 	return (* CLASS (backend)->set_default_timezone) (backend, tzid);
 }
 
-
-/**
- * cal_backend_notify_mode:
- * @backend: A calendar backend.
- * @status: Status of the mode set
- * @mode: the current mode
- *
- * Notifies each of the backend's listeners about the results of a
- * setMode call.
- **/
-void
-cal_backend_notify_mode (CalBackend *backend,
-			 GNOME_Evolution_Calendar_Listener_SetModeStatus status, 
-			 GNOME_Evolution_Calendar_CalMode mode)
-{
-	CalBackendPrivate *priv = backend->priv;
-	GList *l;
-
-	for (l = priv->clients; l; l = l->next)
-		cal_notify_mode (l->data, status, mode);
-}
-
-/**
- * cal_backend_notify_update:
- * @backend: A calendar backend.
- * @uid: UID of object that was updated.
- * 
- * Notifies each of the backend's listeners about an update to a
- * calendar object.
- **/
-void
-cal_backend_notify_update (CalBackend *backend, const char *uid)
-{
-	CalBackendPrivate *priv = backend->priv;
-	GList *l;
-
-	cal_backend_obj_updated (backend, uid);
-	for (l = priv->clients; l; l = l->next)
-		cal_notify_update (l->data, uid);
-}
-
-/**
- * cal_backend_notify_remove:
- * @backend: A calendar backend.
- * @uid: UID of object that was removed.
- * 
- * Notifies each of the backend's listeners about a calendar object
- * that was removed.
- **/
-void
-cal_backend_notify_remove (CalBackend *backend, const char *uid)
-{
-	CalBackendPrivate *priv = backend->priv;
-	GList *l;
-
-	cal_backend_obj_removed (backend, uid);
-	for (l = priv->clients; l; l = l->next)
-		cal_notify_remove (l->data, uid);
-}
-
-/**
- * cal_backend_notify_error:
- * @backend: A calendar backend.
- * @message: Error message
- *
- * Notifies each of the backend's listeners about an error
- **/
-void
-cal_backend_notify_error (CalBackend *backend, const char *message)
-{
-	CalBackendPrivate *priv = backend->priv;
-	GList *l;
-
-	for (l = priv->clients; l; l = l->next)
-		cal_notify_error (l->data, message);
-}
-
-static void
-add_category_cb (gpointer name, gpointer category, gpointer data)
-{
-	GNOME_Evolution_Calendar_StringSeq *seq = data;
-
-	seq->_buffer[seq->_length++] = CORBA_string_dup (name);
-}
-
-static void
-notify_categories_changed (CalBackend *backend)
-{
-	CalBackendPrivate *priv = backend->priv;
-	GNOME_Evolution_Calendar_StringSeq *seq;
-	GList *l;
-
-	/* Build the sequence of category names */
-	seq = GNOME_Evolution_Calendar_StringSeq__alloc ();
-	seq->_length = 0;
-	seq->_maximum = g_hash_table_size (priv->categories);
-	seq->_buffer = CORBA_sequence_CORBA_string_allocbuf (seq->_maximum);
-	CORBA_sequence_set_release (seq, TRUE);
-
-	g_hash_table_foreach (priv->categories, add_category_cb, seq);
-
-	/* Notify the clients */
-	for (l = priv->clients; l; l = l->next)
-		cal_notify_categories_changed (l->data, seq);
-
-	CORBA_free (seq);
-}
-
-static gboolean
-prune_changed_categories (gpointer key, gpointer value, gpointer data)
-{
-	CalBackendCategory *category = value;
-
-	if (!category->refcount) {
-		g_free (category->name);
-		g_free (category);
-	}
-	return TRUE;
-}
-
-static gboolean
-idle_notify_categories_changed (gpointer data)
-{
-	CalBackend *backend = CAL_BACKEND (data);
-	CalBackendPrivate *priv = backend->priv;
-
-	if (g_hash_table_size (priv->changed_categories)) {
-		notify_categories_changed (backend);
-		g_hash_table_foreach_remove (priv->changed_categories, prune_changed_categories, NULL);
-	}
-	return FALSE;
-}
-
-/**
- * cal_backend_ref_categories:
- * @backend: A calendar backend
- * @categories: a list of categories
- *
- * Adds 1 to the refcount of each of the named categories. If any of
- * the categories are new, clients will be notified of the updated
- * category list at idle time.
- **/
-void
-cal_backend_ref_categories (CalBackend *backend, GSList *categories)
-{
-	CalBackendPrivate *priv;
-	CalBackendCategory *c;
-	const char *name;
-
-	priv = backend->priv;
-
-	while (categories) {
-		name = categories->data;
-		c = g_hash_table_lookup (priv->categories, name);
-
-		if (c)
-			c->refcount++;
-		else {
-			/* See if it was recently removed */
-
-			c = g_hash_table_lookup (priv->changed_categories, name);
-			if (c && c->refcount == 0) {
-				/* Move it back to the set of live categories */
-				g_hash_table_remove (priv->changed_categories, c->name);
-
-				c->refcount = 1;
-				g_hash_table_insert (priv->categories, c->name, c);
-			} else {
-				/* Create a new category */
-				c = g_new (CalBackendCategory, 1);
-				c->name = g_strdup (name);
-				c->refcount = 1;
-				g_hash_table_insert (priv->changed_categories, c->name, c);
-			}
-		}
-
-		categories = categories->next;
-	}
-
-	if (g_hash_table_size (priv->changed_categories) &&
-	    !priv->category_idle_id)
-		priv->category_idle_id = g_idle_add (idle_notify_categories_changed, backend);
-}
-
-/**
- * cal_backend_unref_categories:
- * @backend: A calendar backend
- * @categories: a list of categories
- *
- * Subtracts 1 from the refcount of each of the named categories. If
- * any of the refcounts go down to 0, clients will be notified of the
- * updated category list at idle time.
- **/
-void
-cal_backend_unref_categories (CalBackend *backend, GSList *categories)
-{
-	CalBackendPrivate *priv;
-	CalBackendCategory *c;
-	const char *name;
-
-	priv = backend->priv;
-
-	while (categories) {
-		name = categories->data;
-		c = g_hash_table_lookup (priv->categories, name);
-
-		if (c) {
-			g_assert (c != NULL);
-			g_assert (c->refcount > 0);
-
-			c->refcount--;
-
-			if (c->refcount == 0) {
-				g_hash_table_remove (priv->categories, c->name);
-				g_hash_table_insert (priv->changed_categories, c->name, c);
-			}
-		}
-
-		categories = categories->next;
-	}
-
-	if (g_hash_table_size (priv->changed_categories) &&
-	    !priv->category_idle_id)
-		priv->category_idle_id = g_idle_add (idle_notify_categories_changed, backend);
-}
diff --git a/calendar/pcs/cal-backend.h b/calendar/pcs/cal-backend.h
index 962b468fc3..04c3c71f5f 100644
--- a/calendar/pcs/cal-backend.h
+++ b/calendar/pcs/cal-backend.h
@@ -24,6 +24,7 @@
 #ifndef CAL_BACKEND_H
 #define CAL_BACKEND_H
 
+#include <libgnome/gnome-defs.h>
 #include <cal-util/cal-util.h>
 #include <cal-util/cal-component.h>
 #include "pcs/evolution-calendar.h"
@@ -31,16 +32,16 @@
 #include "pcs/cal.h"
 #include "pcs/query.h"
 
-G_BEGIN_DECLS
+BEGIN_GNOME_DECLS
 
 
 
 #define CAL_BACKEND_TYPE            (cal_backend_get_type ())
-#define CAL_BACKEND(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CAL_BACKEND_TYPE, CalBackend))
-#define CAL_BACKEND_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CAL_BACKEND_TYPE,		\
+#define CAL_BACKEND(obj)            (GTK_CHECK_CAST ((obj), CAL_BACKEND_TYPE, CalBackend))
+#define CAL_BACKEND_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), CAL_BACKEND_TYPE,		\
 				     CalBackendClass))
-#define IS_CAL_BACKEND(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CAL_BACKEND_TYPE))
-#define IS_CAL_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CAL_BACKEND_TYPE))
+#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))
 
 /* Open status values */
 typedef enum {
@@ -73,16 +74,13 @@ typedef enum {
 	CAL_BACKEND_GET_ALARMS_INVALID_RANGE
 } CalBackendGetAlarmsForObjectResult;
 
-typedef struct _CalBackendPrivate CalBackendPrivate;
-
 struct _CalBackend {
-	GObject object;
-
-	CalBackendPrivate *priv;
+	GtkObject object;
+	GList *clients;
 };
 
 struct _CalBackendClass {
-	GObjectClass parent_class;
+	GtkObjectClass parent_class;
 
 	/* Notification signals */
 	void (* last_client_gone) (CalBackend *backend);
@@ -152,7 +150,7 @@ struct _CalBackendClass {
 	gboolean (* set_default_timezone) (CalBackend *backend, const char *tzid);
 };
 
-GType cal_backend_get_type (void);
+GtkType cal_backend_get_type (void);
 
 const char *cal_backend_get_uri (CalBackend *backend);
 
@@ -227,17 +225,8 @@ 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);
 
-void cal_backend_notify_mode      (CalBackend *backend,
-				   GNOME_Evolution_Calendar_Listener_SetModeStatus status, 
-				   GNOME_Evolution_Calendar_CalMode mode);
-void cal_backend_notify_update    (CalBackend *backend, const char *uid);
-void cal_backend_notify_remove    (CalBackend *backend, const char *uid);
-void cal_backend_notify_error     (CalBackend *backend, const char *message);
-void cal_backend_ref_categories   (CalBackend *backend, GSList *categories);
-void cal_backend_unref_categories (CalBackend *backend, GSList *categories);
-
 
 
-G_END_DECLS
+END_GNOME_DECLS
 
 #endif
diff --git a/calendar/pcs/cal.c b/calendar/pcs/cal.c
index bd6ffb4b38..c955dd0bb3 100644
--- a/calendar/pcs/cal.c
+++ b/calendar/pcs/cal.c
@@ -28,9 +28,9 @@
 #include "query.h"
 #include "Evolution-Wombat.h"
 
-#define PARENT_TYPE         BONOBO_TYPE_OBJECT
+#define PARENT_TYPE         BONOBO_X_OBJECT_TYPE
 
-static BonoboObjectClass *parent_class;
+static BonoboXObjectClass *parent_class;
 
 /* Private part of the Cal structure */
 struct _CalPrivate {
@@ -64,10 +64,10 @@ impl_Cal_get_uri (PortableServer_Servant servant,
 	return str_uri_copy;
 }
 
-/* Cal::isReadOnly method */
+/* Cal::is_read_only method */
 static CORBA_boolean
-impl_Cal_isReadOnly (PortableServer_Servant servant,
-		     CORBA_Environment *ev)
+impl_Cal_is_read_only (PortableServer_Servant servant,
+		       CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -78,10 +78,10 @@ impl_Cal_isReadOnly (PortableServer_Servant servant,
 	return cal_backend_is_read_only (priv->backend);
 }
 		       
-/* Cal::getEmailAddress method */
+/* Cal::get_cal_address method */
 static CORBA_char *
-impl_Cal_getCalAddress (PortableServer_Servant servant,
-			  CORBA_Environment *ev)
+impl_Cal_get_cal_address (PortableServer_Servant servant,
+			    CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -104,8 +104,8 @@ impl_Cal_getCalAddress (PortableServer_Servant servant,
 		       
 /* Cal::get_alarm_email_address method */
 static CORBA_char *
-impl_Cal_getAlarmEmailAddress (PortableServer_Servant servant,
-			       CORBA_Environment *ev)
+impl_Cal_get_alarm_email_address (PortableServer_Servant servant,
+				  CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -128,8 +128,8 @@ impl_Cal_getAlarmEmailAddress (PortableServer_Servant servant,
 		       
 /* Cal::get_ldap_attribute method */
 static CORBA_char *
-impl_Cal_getLdapAttribute (PortableServer_Servant servant,
-			   CORBA_Environment *ev)
+impl_Cal_get_ldap_attribute (PortableServer_Servant servant,
+			     CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -152,8 +152,8 @@ impl_Cal_getLdapAttribute (PortableServer_Servant servant,
 
 /* Cal::getSchedulingInformation method */
 static CORBA_char *
-impl_Cal_getStaticCapabilities (PortableServer_Servant servant,
-				CORBA_Environment *ev)
+impl_Cal_get_static_capabilities (PortableServer_Servant servant,
+				  CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -180,11 +180,10 @@ uncorba_obj_type (GNOME_Evolution_Calendar_CalObjType type)
 		| ((type & GNOME_Evolution_Calendar_TYPE_JOURNAL) ? CALOBJ_TYPE_JOURNAL : 0));
 }
 
-/* Cal::setMode method */
 static void
-impl_Cal_setMode (PortableServer_Servant servant,
-		  GNOME_Evolution_Calendar_CalMode mode,
-		  CORBA_Environment *ev)
+impl_Cal_set_mode (PortableServer_Servant servant,
+		   GNOME_Evolution_Calendar_CalMode mode,
+		   CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -195,11 +194,11 @@ impl_Cal_setMode (PortableServer_Servant servant,
 	cal_backend_set_mode (priv->backend, mode);
 }
 
-/* Cal::countObjects method */
+/* Cal::get_n_objects method */
 static CORBA_long
-impl_Cal_countObjects (PortableServer_Servant servant,
-		       GNOME_Evolution_Calendar_CalObjType type,
-		       CORBA_Environment *ev)
+impl_Cal_get_n_objects (PortableServer_Servant servant,
+			GNOME_Evolution_Calendar_CalObjType type,
+			CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -214,32 +213,33 @@ impl_Cal_countObjects (PortableServer_Servant servant,
 	return n;
 }
 
+/* Cal::get_object method */
 static GNOME_Evolution_Calendar_CalObj
-impl_Cal_getDefaultObject (PortableServer_Servant servant,
- 			     GNOME_Evolution_Calendar_CalObjType type,
- 			     CORBA_Environment *ev)
+impl_Cal_get_default_object (PortableServer_Servant servant,
+			     GNOME_Evolution_Calendar_CalObjType type,
+			     CORBA_Environment *ev)
 {
- 	Cal *cal;
- 	CalPrivate *priv;
- 	GNOME_Evolution_Calendar_CalObj calobj_copy;
- 	char *calobj;
- 	
- 
- 	cal = CAL (bonobo_object_from_servant (servant));
- 	priv = cal->priv;
- 
- 	calobj = cal_backend_get_default_object (priv->backend, type);
- 	calobj_copy = CORBA_string_dup (calobj);
- 	g_free (calobj);
- 
- 	return calobj_copy;
+	Cal *cal;
+	CalPrivate *priv;
+	GNOME_Evolution_Calendar_CalObj calobj_copy;
+	char *calobj;
+	
+
+	cal = CAL (bonobo_object_from_servant (servant));
+	priv = cal->priv;
+
+	calobj = cal_backend_get_default_object (priv->backend, type);
+	calobj_copy = CORBA_string_dup (calobj);
+	g_free (calobj);
+
+	return calobj_copy;
 }
 
-/* Cal::getObject method */
+/* Cal::get_object method */
 static GNOME_Evolution_Calendar_CalObj
-impl_Cal_getObject (PortableServer_Servant servant,
-		    const CORBA_char *uid,
-		    CORBA_Environment *ev)
+impl_Cal_get_object (PortableServer_Servant servant,
+		     const GNOME_Evolution_Calendar_CalObjUID uid,
+		     CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -289,11 +289,11 @@ build_uid_seq (GList *uids)
 	return seq;
 }
 
-/* Cal::getUIDs method */
+/* Cal::get_uids method */
 static GNOME_Evolution_Calendar_CalObjUIDSeq *
-impl_Cal_getUIDs (PortableServer_Servant servant,
-		  GNOME_Evolution_Calendar_CalObjType type,
-		  CORBA_Environment *ev)
+impl_Cal_get_uids (PortableServer_Servant servant,
+		   GNOME_Evolution_Calendar_CalObjType type,
+		   CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -314,12 +314,12 @@ impl_Cal_getUIDs (PortableServer_Servant servant,
 	return seq;
 }
 
-/* Cal::getChanges method */
+/* Cal::get_changes method */
 static GNOME_Evolution_Calendar_CalObjChangeSeq *
-impl_Cal_getChanges (PortableServer_Servant servant,
-		     GNOME_Evolution_Calendar_CalObjType type,
-		     const CORBA_char *change_id,
-		     CORBA_Environment *ev)
+impl_Cal_get_changes (PortableServer_Servant servant,
+		      GNOME_Evolution_Calendar_CalObjType type,
+		      const CORBA_char *change_id,
+		      CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -333,13 +333,13 @@ impl_Cal_getChanges (PortableServer_Servant servant,
 	return cal_backend_get_changes (priv->backend, t, change_id);
 }
 
-/* Cal::getObjectsInRange method */
+/* Cal::get_objects_in_range method */
 static GNOME_Evolution_Calendar_CalObjUIDSeq *
-impl_Cal_getObjectsInRange (PortableServer_Servant servant,
-			    GNOME_Evolution_Calendar_CalObjType type,
-			    GNOME_Evolution_Calendar_Time_t start,
-			    GNOME_Evolution_Calendar_Time_t end,
-			    CORBA_Environment *ev)
+impl_Cal_get_objects_in_range (PortableServer_Servant servant,
+			       GNOME_Evolution_Calendar_CalObjType type,
+			       GNOME_Evolution_Calendar_Time_t start,
+			       GNOME_Evolution_Calendar_Time_t end,
+			       CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -395,13 +395,13 @@ build_fb_seq (GList *obj_list)
 	return seq;
 }
 
-/* Cal::getFreeBusy method */
+/* Cal::get_free_busy method */
 static GNOME_Evolution_Calendar_CalObjSeq *
-impl_Cal_getFreeBusy (PortableServer_Servant servant,
-		      const GNOME_Evolution_Calendar_UserList *user_list,
-		      const GNOME_Evolution_Calendar_Time_t start,
-		      const GNOME_Evolution_Calendar_Time_t end,
-		      CORBA_Environment *ev)
+impl_Cal_get_free_busy (PortableServer_Servant servant,
+			const GNOME_Evolution_Calendar_UserList *user_list,
+			const GNOME_Evolution_Calendar_Time_t start,
+			const GNOME_Evolution_Calendar_Time_t end,
+			CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -440,12 +440,12 @@ impl_Cal_getFreeBusy (PortableServer_Servant servant,
         return seq;
 }
 
-/* Cal::getAlarmsInRange method */
+/* Cal::get_alarms_in_range method */
 static GNOME_Evolution_Calendar_CalComponentAlarmsSeq *
-impl_Cal_getAlarmsInRange (PortableServer_Servant servant,
-			   GNOME_Evolution_Calendar_Time_t start,
-			   GNOME_Evolution_Calendar_Time_t end,
-			   CORBA_Environment *ev)
+impl_Cal_get_alarms_in_range (PortableServer_Servant servant,
+			      GNOME_Evolution_Calendar_Time_t start,
+			      GNOME_Evolution_Calendar_Time_t end,
+			      CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -473,13 +473,13 @@ impl_Cal_getAlarmsInRange (PortableServer_Servant servant,
 	return seq;
 }
 
-/* Cal::getAlarmsForObject method */
+/* Cal::get_alarms_for_object method */
 static GNOME_Evolution_Calendar_CalComponentAlarms *
-impl_Cal_getAlarmsForObject (PortableServer_Servant servant,
-			     const CORBA_char *uid,
-			     GNOME_Evolution_Calendar_Time_t start,
-			     GNOME_Evolution_Calendar_Time_t end,
-			     CORBA_Environment * ev)
+impl_Cal_get_alarms_for_object (PortableServer_Servant servant,
+				const GNOME_Evolution_Calendar_CalObjUID uid,
+				GNOME_Evolution_Calendar_Time_t start,
+				GNOME_Evolution_Calendar_Time_t end,
+				CORBA_Environment * ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -513,12 +513,12 @@ impl_Cal_getAlarmsForObject (PortableServer_Servant servant,
 	}
 }
 
-/* Cal::updateObjects method */
+/* Cal::update_objects method */
 static void
-impl_Cal_updateObjects (PortableServer_Servant servant,
-			const CORBA_char *calobj,
-			const GNOME_Evolution_Calendar_CalObjModType mod,
-			CORBA_Environment *ev)
+impl_Cal_update_objects (PortableServer_Servant servant,
+			 const GNOME_Evolution_Calendar_CalObj calobj,
+			 const GNOME_Evolution_Calendar_CalObjModType mod,
+			 CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -543,12 +543,12 @@ impl_Cal_updateObjects (PortableServer_Servant servant,
 	}
 }
 
-/* Cal::removeObject method */
+/* Cal::remove_object method */
 static void
-impl_Cal_removeObject (PortableServer_Servant servant,
-		       const CORBA_char *uid,
-		       const GNOME_Evolution_Calendar_CalObjModType mod,
-		       CORBA_Environment *ev)
+impl_Cal_remove_object (PortableServer_Servant servant,
+			const GNOME_Evolution_Calendar_CalObjUID uid,
+			const GNOME_Evolution_Calendar_CalObjModType mod,
+			CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -573,12 +573,12 @@ impl_Cal_removeObject (PortableServer_Servant servant,
 	}
 }
 
-/* Cal::sendObject method */
+/* Cal::send_object method */
 static GNOME_Evolution_Calendar_CalObj
-impl_Cal_sendObject (PortableServer_Servant servant,
-		     const CORBA_char *calobj,
-		     GNOME_Evolution_Calendar_UserList **user_list,
-		     CORBA_Environment *ev)
+impl_Cal_send_object (PortableServer_Servant servant,
+		      const GNOME_Evolution_Calendar_CalObj calobj,
+		      GNOME_Evolution_Calendar_UserList **user_list,
+		      CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -622,10 +622,10 @@ impl_Cal_sendObject (PortableServer_Servant servant,
 
 /* Cal::getQuery implementation */
 static GNOME_Evolution_Calendar_Query
-impl_Cal_getQuery (PortableServer_Servant servant,
-		   const CORBA_char *sexp,
-		   GNOME_Evolution_Calendar_QueryListener ql,
-		   CORBA_Environment *ev)
+impl_Cal_get_query (PortableServer_Servant servant,
+		    const CORBA_char *sexp,
+		    GNOME_Evolution_Calendar_QueryListener ql,
+		    CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -645,7 +645,6 @@ impl_Cal_getQuery (PortableServer_Servant servant,
 	CORBA_exception_init (&ev2);
 	query_copy = CORBA_Object_duplicate (BONOBO_OBJREF (query), &ev2);
 	if (BONOBO_EX (&ev2)) {
-		bonobo_object_unref (query);
 		CORBA_exception_free (&ev2);
 		g_message ("Cal_get_query(): Could not duplicate the query reference");
 		bonobo_exception_set (ev, ex_GNOME_Evolution_Calendar_Cal_CouldNotCreate);
@@ -657,11 +656,11 @@ impl_Cal_getQuery (PortableServer_Servant servant,
 	return query_copy;
 }
 
-/* Cal::setDefaultTimezone method */
+/* Cal::set_default_timezone method */
 static void
-impl_Cal_setDefaultTimezone (PortableServer_Servant servant,
-			     const CORBA_char *tzid,
-			     CORBA_Environment *ev)
+impl_Cal_set_default_timezone (PortableServer_Servant servant,
+			       const GNOME_Evolution_Calendar_CalTimezoneObjUID tzid,
+			       CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -677,11 +676,11 @@ impl_Cal_setDefaultTimezone (PortableServer_Servant servant,
 	}
 }
 
-/* Cal::getTimezoneObject method */
+/* Cal::get_timezone_object method */
 static GNOME_Evolution_Calendar_CalObj
-impl_Cal_getTimezoneObject (PortableServer_Servant servant,
-			    const CORBA_char *tzid,
-			    CORBA_Environment *ev)
+impl_Cal_get_timezone_object (PortableServer_Servant servant,
+			      const GNOME_Evolution_Calendar_CalTimezoneObjUID tzid,
+			      CORBA_Environment *ev)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -780,7 +779,7 @@ cal_new (CalBackend *backend, GNOME_Evolution_Calendar_Listener listener)
 	g_return_val_if_fail (backend != NULL, NULL);
 	g_return_val_if_fail (IS_CAL_BACKEND (backend), NULL);
 
-	cal = CAL (g_object_new (CAL_TYPE, NULL));
+	cal = CAL (gtk_type_new (CAL_TYPE));
 
 	retval = cal_construct (cal, backend, listener);
 	if (!retval) {
@@ -794,7 +793,7 @@ cal_new (CalBackend *backend, GNOME_Evolution_Calendar_Listener listener)
 
 /* Destroy handler for the calendar */
 static void
-cal_finalize (GObject *object)
+cal_destroy (GtkObject *object)
 {
 	Cal *cal;
 	CalPrivate *priv;
@@ -818,8 +817,8 @@ cal_finalize (GObject *object)
 
 	g_free (priv);
 
-	if (G_OBJECT_CLASS (parent_class)->finalize)
-		(* G_OBJECT_CLASS (parent_class)->finalize) (object);
+	if (GTK_OBJECT_CLASS (parent_class)->destroy)
+		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 }
 
 
@@ -828,43 +827,43 @@ cal_finalize (GObject *object)
 static void
 cal_class_init (CalClass *klass)
 {
-	GObjectClass *object_class = (GObjectClass *) klass;
+	GtkObjectClass *object_class = (GtkObjectClass *) klass;
 	POA_GNOME_Evolution_Calendar_Cal__epv *epv = &klass->epv;
 
-	parent_class = g_type_class_peek_parent (klass);
+	parent_class = gtk_type_class (PARENT_TYPE);
 
 	/* Class method overrides */
-	object_class->finalize = cal_finalize;
+	object_class->destroy = cal_destroy;
 
 	/* Epv methods */
 	epv->_get_uri = impl_Cal_get_uri;
-	epv->isReadOnly = impl_Cal_isReadOnly;
-	epv->getCalAddress = impl_Cal_getCalAddress;
- 	epv->getAlarmEmailAddress = impl_Cal_getAlarmEmailAddress;
- 	epv->getLdapAttribute = impl_Cal_getLdapAttribute;
- 	epv->getStaticCapabilities = impl_Cal_getStaticCapabilities;
-	epv->setMode = impl_Cal_setMode;
-	epv->countObjects = impl_Cal_countObjects;
-	epv->getDefaultObject = impl_Cal_getDefaultObject;
-	epv->getObject = impl_Cal_getObject;
-	epv->setDefaultTimezone = impl_Cal_setDefaultTimezone;
-	epv->getTimezoneObject = impl_Cal_getTimezoneObject;
-	epv->getUIDs = impl_Cal_getUIDs;
-	epv->getChanges = impl_Cal_getChanges;
-	epv->getObjectsInRange = impl_Cal_getObjectsInRange;
-	epv->getFreeBusy = impl_Cal_getFreeBusy;
-	epv->getAlarmsInRange = impl_Cal_getAlarmsInRange;
-	epv->getAlarmsForObject = impl_Cal_getAlarmsForObject;
-	epv->updateObjects = impl_Cal_updateObjects;
-	epv->removeObject = impl_Cal_removeObject;
-	epv->sendObject = impl_Cal_sendObject;
-	epv->getQuery = impl_Cal_getQuery;
+	epv->isReadOnly = impl_Cal_is_read_only;
+	epv->getCalAddress = impl_Cal_get_cal_address;
+	epv->getAlarmEmailAddress = impl_Cal_get_alarm_email_address;
+	epv->getLdapAttribute = impl_Cal_get_ldap_attribute;
+	epv->getStaticCapabilities = impl_Cal_get_static_capabilities;
+	epv->setMode = impl_Cal_set_mode;
+	epv->countObjects = impl_Cal_get_n_objects;
+	epv->getDefaultObject = impl_Cal_get_default_object;
+	epv->getObject = impl_Cal_get_object;
+	epv->setDefaultTimezone = impl_Cal_set_default_timezone;
+	epv->getTimezoneObject = impl_Cal_get_timezone_object;
+	epv->getUIDs = impl_Cal_get_uids;
+	epv->getChanges = impl_Cal_get_changes;
+	epv->getObjectsInRange = impl_Cal_get_objects_in_range;
+	epv->getFreeBusy = impl_Cal_get_free_busy;
+	epv->getAlarmsInRange = impl_Cal_get_alarms_in_range;
+	epv->getAlarmsForObject = impl_Cal_get_alarms_for_object;
+	epv->updateObjects = impl_Cal_update_objects;
+	epv->removeObject = impl_Cal_remove_object;
+	epv->sendObject = impl_Cal_send_object; 
+	epv->getQuery = impl_Cal_get_query;
 }
 
 
 /* Object initialization function for the calendar */
 static void
-cal_init (Cal *cal, CalClass *klass)
+cal_init (Cal *cal)
 {
 	CalPrivate *priv;
 
@@ -874,7 +873,7 @@ cal_init (Cal *cal, CalClass *klass)
 	priv->listener = CORBA_OBJECT_NIL;
 }
 
-BONOBO_TYPE_FUNC_FULL (Cal, GNOME_Evolution_Calendar_Cal, PARENT_TYPE, cal);
+BONOBO_X_TYPE_FUNC_FULL (Cal, GNOME_Evolution_Calendar_Cal, PARENT_TYPE, cal);
 
 /**
  * cal_notify_mode: