GNOME.org
 

[evolution-data-server] libedata-cal: Use new base classes in libebackend.

commit eecd901176c1945d069b11ef74771e662ec5714d
Author: Matthew Barnes <mbarnes redhat com>
Date:   Fri Sep 9 13:27:56 2011 -0400

    libedata-cal: Use new base classes in libebackend.

 calendar/libedata-cal/e-cal-backend-factory.c      |  105 ++--
 calendar/libedata-cal/e-cal-backend-factory.h      |   63 +-
 calendar/libedata-cal/e-cal-backend.c              |  216 +-----
 calendar/libedata-cal/e-cal-backend.h              |   11 +-
 calendar/libedata-cal/e-data-cal-factory.c         |  832 ++++----------------
 calendar/libedata-cal/e-data-cal-factory.h         |   53 +-
 calendar/libedata-cal/e-data-cal.c                 |  263 +++++--
 calendar/libedata-cal/e-data-cal.h                 |    3 +-
 .../libedata-cal/libedata-cal-sections.txt         |   17 +-
 .../libedata-cal/tmpl/e-cal-backend-factory.sgml   |   28 -
 .../calendar/libedata-cal/tmpl/e-cal-backend.sgml  |   53 --
 .../libedata-cal/tmpl/e-data-cal-factory.sgml      |   57 --
 .../calendar/libedata-cal/tmpl/e-data-cal.sgml     |   15 +-
 13 files changed, 464 insertions(+), 1252 deletions(-)
---
diff --git a/calendar/libedata-cal/e-cal-backend-factory.c b/calendar/libedata-cal/e-cal-backend-factory.c
index 75f3fc4..45238b3 100644
--- a/calendar/libedata-cal/e-cal-backend-factory.c
+++ b/calendar/libedata-cal/e-cal-backend-factory.c
@@ -7,72 +7,79 @@
  * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
  */
 
-#ifdef HAVE_CONFIG_H
 #include <config.h>
-#endif
-
 #include <string.h>
 
+#include "e-cal-backend.h"
 #include "e-cal-backend-factory.h"
 
-G_DEFINE_TYPE (ECalBackendFactory, e_cal_backend_factory, G_TYPE_OBJECT)
+G_DEFINE_ABSTRACT_TYPE (
+	ECalBackendFactory,
+	e_cal_backend_factory,
+	E_TYPE_BACKEND_FACTORY)
 
-static void
-e_cal_backend_factory_init (ECalBackendFactory *factory)
+static const gchar *
+cal_backend_factory_get_hash_key (EBackendFactory *factory)
 {
-}
+	ECalBackendFactoryClass *class;
+	const gchar *component_name;
+	gchar *hash_key;
+	gsize length;
 
-static void
-e_cal_backend_factory_class_init (ECalBackendFactoryClass *klass)
-{
+	class = E_CAL_BACKEND_FACTORY_GET_CLASS (factory);
+	g_return_val_if_fail (class->factory_name != NULL, NULL);
+
+	switch (class->component_kind) {
+		case ICAL_VEVENT_COMPONENT:
+			component_name = "VEVENT";
+			break;
+		case ICAL_VTODO_COMPONENT:
+			component_name = "VTODO";
+			break;
+		case ICAL_VJOURNAL_COMPONENT:
+			component_name = "VJOURNAL";
+			break;
+		default:
+			g_return_val_if_reached (NULL);
+	}
+
+	/* Hash Key: FACTORY_NAME ':' COMPONENT_NAME */
+	length = strlen (class->factory_name) + strlen (component_name) + 2;
+	hash_key = g_alloca (length);
+	g_snprintf (
+		hash_key, length, "%s:%s",
+		class->factory_name, component_name);
+
+	return g_intern_string (hash_key);
 }
 
-/**
- * e_cal_backend_factory_get_kind:
- * @factory: An #ECalBackendFactory object.
- *
- * Gets the component type of the factory.
- *
- * Returns: The kind of factory.
- */
-icalcomponent_kind
-e_cal_backend_factory_get_kind (ECalBackendFactory *factory)
+static EBackend *
+cal_backend_factory_new_backend (EBackendFactory *factory,
+                                 ESource *source)
 {
-	g_return_val_if_fail (E_IS_CAL_BACKEND_FACTORY (factory), 0/*XXX */);
+	ECalBackendFactoryClass *class;
 
-	return E_CAL_BACKEND_FACTORY_GET_CLASS (factory)->get_kind (factory);
+	class = E_CAL_BACKEND_FACTORY_GET_CLASS (factory);
+	g_return_val_if_fail (g_type_is_a (
+		class->backend_type, E_TYPE_CAL_BACKEND), NULL);
+
+	return g_object_new (
+		class->backend_type,
+		"kind", class->component_kind,
+		"source", source, NULL);
 }
 
-/**
- * e_cal_backend_factory_get_protocol:
- * @factory: An #ECalBackendFactory object.
- *
- * Gets the protocol used by the factory.
- *
- * Returns: The protocol.
- */
-const gchar *
-e_cal_backend_factory_get_protocol (ECalBackendFactory *factory)
+static void
+e_cal_backend_factory_class_init (ECalBackendFactoryClass *class)
 {
-	g_return_val_if_fail (E_IS_CAL_BACKEND_FACTORY (factory), NULL);
+	EBackendFactoryClass *factory_class;
 
-	return E_CAL_BACKEND_FACTORY_GET_CLASS (factory)->get_protocol (factory);
+	factory_class = E_BACKEND_FACTORY_CLASS (class);
+	factory_class->get_hash_key = cal_backend_factory_get_hash_key;
+	factory_class->new_backend = cal_backend_factory_new_backend;
 }
 
-/**
- * e_cal_backend_factory_new_backend:
- * @factory: An #ECalBackendFactory object.
- * @source: An #ESource.
- *
- * Creates a new backend for the given @source.
- *
- * Returns: The newly created backend, or NULL if there was an error.
- */
-ECalBackend *
-e_cal_backend_factory_new_backend (ECalBackendFactory *factory,
-                                   ESource *source)
+static void
+e_cal_backend_factory_init (ECalBackendFactory *factory)
 {
-	g_return_val_if_fail (E_IS_CAL_BACKEND_FACTORY (factory), NULL);
-
-	return E_CAL_BACKEND_FACTORY_GET_CLASS (factory)->new_backend (factory, source);
 }
diff --git a/calendar/libedata-cal/e-cal-backend-factory.h b/calendar/libedata-cal/e-cal-backend-factory.h
index 4c2b668..1f636f6 100644
--- a/calendar/libedata-cal/e-cal-backend-factory.h
+++ b/calendar/libedata-cal/e-cal-backend-factory.h
@@ -20,40 +20,53 @@
  * Author: Chris Toshok <toshok ximian com>
  */
 
-#ifndef _E_CAL_BACKEND_FACTORY_H_
-#define _E_CAL_BACKEND_FACTORY_H_
+#ifndef E_CAL_BACKEND_FACTORY_H
+#define E_CAL_BACKEND_FACTORY_H
 
-#include "e-cal-backend.h"
+#include <libical/ical.h>
+#include <libebackend/e-backend-factory.h>
 
-G_BEGIN_DECLS
+/* Standard GObject macros */
+#define E_TYPE_CAL_BACKEND_FACTORY \
+	(e_cal_backend_factory_get_type ())
+#define E_CAL_BACKEND_FACTORY(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactory))
+#define E_CAL_BACKEND_FACTORY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactoryClass))
+#define E_IS_CAL_BACKEND_FACTORY(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_CAL_BACKEND_FACTORY))
+#define E_IS_CAL_BACKEND_FACTORY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_CAL_BACKEND_FACTORY))
+#define E_CAL_BACKEND_FACTORY_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactoryClass))
 
-#define E_TYPE_CAL_BACKEND_FACTORY        (e_cal_backend_factory_get_type ())
-#define E_CAL_BACKEND_FACTORY(o)          (G_TYPE_CHECK_INSTANCE_CAST ((o), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactory))
-#define E_CAL_BACKEND_FACTORY_CLASS(k)    (G_TYPE_CHECK_CLASS_CAST((k), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactoryClass))
-#define E_IS_CAL_BACKEND_FACTORY(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), E_TYPE_CAL_BACKEND_FACTORY))
-#define E_IS_CAL_BACKEND_FACTORY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), E_TYPE_CAL_BACKEND_FACTORY))
-#define E_CAL_BACKEND_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), E_TYPE_CAL_BACKEND_FACTORY, ECalBackendFactoryClass))
+G_BEGIN_DECLS
 
+typedef struct _ECalBackendFactory ECalBackendFactory;
+typedef struct _ECalBackendFactoryClass ECalBackendFactoryClass;
 typedef struct _ECalBackendFactoryPrivate ECalBackendFactoryPrivate;
 
-typedef struct {
-	GObject            parent_object;
-} ECalBackendFactory;
-
-typedef struct {
-	GObjectClass parent_class;
+struct _ECalBackendFactory {
+	EBackendFactory parent;
+};
 
-	icalcomponent_kind (*get_kind)     (ECalBackendFactory *factory);
-	const gchar *        (*get_protocol) (ECalBackendFactory *factory);
-	ECalBackend *       (*new_backend)  (ECalBackendFactory *factory, ESource *source);
-} ECalBackendFactoryClass;
+struct _ECalBackendFactoryClass {
+	EBackendFactoryClass parent_class;
 
-GType               e_cal_backend_factory_get_type              (void);
+	/* Subclasses just need to set these
+	 * class members, we handle the rest. */
+	const gchar *factory_name;
+	icalcomponent_kind component_kind;
+	GType backend_type;
+};
 
-icalcomponent_kind  e_cal_backend_factory_get_kind              (ECalBackendFactory *factory);
-const gchar *         e_cal_backend_factory_get_protocol          (ECalBackendFactory *factory);
-ECalBackend *        e_cal_backend_factory_new_backend           (ECalBackendFactory *factory, ESource *source);
+GType		e_cal_backend_factory_get_type		(void) G_GNUC_CONST;
 
 G_END_DECLS
 
-#endif /* _E_CAL_BACKEND_FACTORY_H_ */
+#endif /* E_CAL_BACKEND_FACTORY_H */
diff --git a/calendar/libedata-cal/e-cal-backend.c b/calendar/libedata-cal/e-cal-backend.c
index a6aa88a..abf046d 100644
--- a/calendar/libedata-cal/e-cal-backend.c
+++ b/calendar/libedata-cal/e-cal-backend.c
@@ -36,12 +36,10 @@
 
 /* Private part of the CalBackend structure */
 struct _ECalBackendPrivate {
-	/* The source for this backend */
-	ESource *source;
 	/* The kind of components for this backend */
 	icalcomponent_kind kind;
 
-	gboolean opening, opened, readonly, removed, online;
+	gboolean opening, opened, readonly, removed;
 
 	/* URI, from source. This is cached, since we return const. */
 	gchar *uri;
@@ -64,46 +62,12 @@ struct _ECalBackendPrivate {
 enum {
 	PROP_0,
 	PROP_CACHE_DIR,
-	PROP_KIND,
-	PROP_SOURCE,
-	PROP_URI
-};
-
-/* Signal IDs */
-enum {
-	LAST_CLIENT_GONE,
-	LAST_SIGNAL
+	PROP_KIND
 };
 
-static guint signals[LAST_SIGNAL];
-
 static void e_cal_backend_remove_client_private (ECalBackend *backend, EDataCal *cal, gboolean weak_unref);
 
-G_DEFINE_TYPE (ECalBackend, e_cal_backend, G_TYPE_OBJECT);
-
-static void
-source_changed_cb (ESource *source,
-                   ECalBackend *backend)
-{
-	ECalBackendPrivate *priv;
-	gchar *suri;
-
-	g_return_if_fail (source != NULL);
-	g_return_if_fail (backend != NULL);
-	g_return_if_fail (E_IS_CAL_BACKEND (backend));
-
-	priv = backend->priv;
-	g_return_if_fail (priv != NULL);
-	g_return_if_fail (priv->source == source);
-
-	suri = e_source_get_uri (priv->source);
-	if (!priv->uri || (suri && !g_str_equal (priv->uri, suri))) {
-		g_free (priv->uri);
-		priv->uri = suri;
-	} else {
-		g_free (suri);
-	}
-}
+G_DEFINE_TYPE (ECalBackend, e_cal_backend, E_TYPE_BACKEND);
 
 static void
 cal_backend_set_default_cache_dir (ECalBackend *backend)
@@ -118,7 +82,7 @@ cal_backend_set_default_cache_dir (ECalBackend *backend)
 	user_cache_dir = e_get_user_cache_dir ();
 
 	kind = e_cal_backend_get_kind (backend);
-	source = e_cal_backend_get_source (backend);
+	source = e_backend_get_source (E_BACKEND (backend));
 
 	switch (kind) {
 		case ICAL_VEVENT_COMPONENT:
@@ -146,40 +110,6 @@ cal_backend_set_default_cache_dir (ECalBackend *backend)
 }
 
 static void
-cal_backend_set_source (ECalBackend *backend,
-                        ESource *source)
-{
-	if (backend->priv->source != NULL) {
-		g_signal_handlers_disconnect_matched (backend->priv->source, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, source_changed_cb, backend);
-		g_object_unref (backend->priv->source);
-	}
-
-	if (source != NULL)
-		g_signal_connect (
-			g_object_ref (source), "changed",
-			G_CALLBACK (source_changed_cb), backend);
-
-	backend->priv->source = source;
-
-	/* Cache the URI */
-	if (source != NULL) {
-		g_free (backend->priv->uri);
-		backend->priv->uri = e_source_get_uri (source);
-	}
-}
-
-static void
-cal_backend_set_uri (ECalBackend *backend,
-                     const gchar *uri)
-{
-	/* ESource's URI gets priority. */
-	if (backend->priv->source == NULL) {
-		g_free (backend->priv->uri);
-		backend->priv->uri = g_strdup (uri);
-	}
-}
-
-static void
 cal_backend_set_kind (ECalBackend *backend,
                       icalcomponent_kind kind)
 {
@@ -203,7 +133,7 @@ cal_backend_get_backend_property (ECalBackend *backend,
 	} else if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_OPENING)) {
 		e_data_cal_respond_get_backend_property (cal, opid, NULL, e_cal_backend_is_opening (backend) ? "TRUE" : "FALSE");
 	} else if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_ONLINE)) {
-		e_data_cal_respond_get_backend_property (cal, opid, NULL, e_cal_backend_is_online (backend) ? "TRUE" : "FALSE");
+		e_data_cal_respond_get_backend_property (cal, opid, NULL, e_backend_get_online (E_BACKEND (backend)) ? "TRUE" : "FALSE");
 	} else if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_READONLY)) {
 		e_data_cal_respond_get_backend_property (cal, opid, NULL, e_cal_backend_is_readonly (backend) ? "TRUE" : "FALSE");
 	} else if (g_str_equal (prop_name, CLIENT_BACKEND_PROPERTY_CACHE_DIR)) {
@@ -246,16 +176,6 @@ cal_backend_set_property (GObject *object,
 				E_CAL_BACKEND (object),
 				g_value_get_ulong (value));
 			return;
-		case PROP_SOURCE:
-			cal_backend_set_source (
-				E_CAL_BACKEND (object),
-				g_value_get_object (value));
-			return;
-		case PROP_URI:
-			cal_backend_set_uri (
-				E_CAL_BACKEND (object),
-				g_value_get_string (value));
-			return;
 	}
 
 	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -278,16 +198,6 @@ cal_backend_get_property (GObject *object,
 				value, e_cal_backend_get_kind (
 				E_CAL_BACKEND (object)));
 			return;
-		case PROP_SOURCE:
-			g_value_set_object (
-				value, e_cal_backend_get_source (
-				E_CAL_BACKEND (object)));
-			return;
-		case PROP_URI:
-			g_value_set_string (
-				value, e_cal_backend_get_uri (
-				E_CAL_BACKEND (object)));
-			return;
 	}
 
 	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -309,14 +219,8 @@ cal_backend_finalize (GObject *object)
 	g_mutex_free (priv->clients_mutex);
 	g_mutex_free (priv->views_mutex);
 
-	g_free (priv->uri);
 	g_free (priv->cache_dir);
 
-	if (priv->source) {
-		g_signal_handlers_disconnect_matched (priv->source, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, object);
-		g_object_unref (priv->source);
-	}
-
 	/* Chain up to parent's finalize() method. */
 	G_OBJECT_CLASS (e_cal_backend_parent_class)->finalize (object);
 }
@@ -367,37 +271,6 @@ e_cal_backend_class_init (ECalBackendClass *klass)
 			ICAL_NO_COMPONENT,
 			G_PARAM_READWRITE |
 			G_PARAM_CONSTRUCT_ONLY));
-
-	g_object_class_install_property (
-		object_class,
-		PROP_SOURCE,
-		g_param_spec_object (
-			"source",
-			NULL,
-			NULL,
-			E_TYPE_SOURCE,
-			G_PARAM_READWRITE |
-			G_PARAM_CONSTRUCT_ONLY));
-
-	g_object_class_install_property (
-		object_class,
-		PROP_URI,
-		g_param_spec_string (
-			"uri",
-			NULL,
-			NULL,
-			"",
-			G_PARAM_READWRITE |
-			G_PARAM_CONSTRUCT_ONLY));
-
-	signals[LAST_CLIENT_GONE] = g_signal_new (
-		"last_client_gone",
-		G_TYPE_FROM_CLASS (klass),
-		G_SIGNAL_RUN_FIRST,
-		G_STRUCT_OFFSET (ECalBackendClass, last_client_gone),
-		NULL, NULL,
-		g_cclosure_marshal_VOID__VOID,
-		G_TYPE_NONE, 0);
 }
 
 static void
@@ -413,40 +286,6 @@ e_cal_backend_init (ECalBackend *backend)
 	backend->priv->views_mutex = g_mutex_new ();
 
 	backend->priv->readonly = TRUE;
-	backend->priv->online = FALSE;
-}
-
-/**
- * e_cal_backend_get_source:
- * @backend: an #ECalBackend
- *
- * Gets the #ESource associated with the given backend.
- *
- * Returns: The #ESource for the backend.
- */
-ESource *
-e_cal_backend_get_source (ECalBackend *backend)
-{
-	g_return_val_if_fail (E_IS_CAL_BACKEND (backend), NULL);
-
-	return backend->priv->source;
-}
-
-/**
- * e_cal_backend_get_uri:
- * @backend: an #ECalBackend
- *
- * Queries the URI of a calendar backend, which must already have an open
- * calendar.
- *
- * Returns: The URI where the calendar is stored.
- **/
-const gchar *
-e_cal_backend_get_uri (ECalBackend *backend)
-{
-	g_return_val_if_fail (E_IS_CAL_BACKEND (backend), NULL);
-
-	return backend->priv->uri;
 }
 
 /**
@@ -466,22 +305,6 @@ e_cal_backend_get_kind (ECalBackend *backend)
 }
 
 /**
- * e_cal_backend_is_online:
- * @backend: an #ECalBackend
- *
- * Returns: Whether is backend online.
- *
- * Since: 3.2
- **/
-gboolean
-e_cal_backend_is_online (ECalBackend *backend)
-{
-	g_return_val_if_fail (E_IS_CAL_BACKEND (backend), FALSE);
-
-	return backend->priv->online;
-}
-
-/**
  * e_cal_backend_is_opened:
  * @backend: an #ECalBackend
  *
@@ -776,7 +599,7 @@ e_cal_backend_remove_client_private (ECalBackend *backend,
 	 */
 	if (!priv->clients) {
 		priv->opening = FALSE;
-		g_signal_emit (backend, signals[LAST_CLIENT_GONE], 0);
+		e_backend_last_client_gone (E_BACKEND (backend));
 	}
 }
 
@@ -898,26 +721,6 @@ e_cal_backend_set_notification_proxy (ECalBackend *backend,
 }
 
 /**
- * e_cal_backend_set_online:
- * @backend: A calendar backend
- * @is_online: Whether is online
- *
- * Sets the online mode of the calendar
- *
- * Since: 3.2
- */
-void
-e_cal_backend_set_online (ECalBackend *backend,
-                          gboolean is_online)
-{
-	g_return_if_fail (backend != NULL);
-	g_return_if_fail (E_IS_CAL_BACKEND (backend));
-	g_return_if_fail (E_CAL_BACKEND_GET_CLASS (backend)->set_online != NULL);
-
-	(* E_CAL_BACKEND_GET_CLASS (backend)->set_online) (backend, is_online);
-}
-
-/**
  * e_cal_backend_open:
  * @backend: an #ECalBackend
  * @cal: an #EDataCal
@@ -987,10 +790,14 @@ e_cal_backend_open (ECalBackend *backend,
 	g_mutex_lock (backend->priv->clients_mutex);
 
 	if (e_cal_backend_is_opened (backend)) {
+		gboolean online;
+
 		g_mutex_unlock (backend->priv->clients_mutex);
 
 		e_data_cal_report_readonly (cal, backend->priv->readonly);
-		e_data_cal_report_online (cal, backend->priv->online);
+
+		online = e_backend_get_online (E_BACKEND (backend));
+		e_data_cal_report_online (cal, online);
 
 		e_cal_backend_respond_opened (backend, cal, opid, NULL);
 	} else if (e_cal_backend_is_opening (backend)) {
@@ -1854,7 +1661,6 @@ e_cal_backend_notify_online (ECalBackend *backend,
 	GSList *clients;
 
 	priv = backend->priv;
-	priv->online = is_online;
 
 	if (priv->notification_proxy) {
 		e_cal_backend_notify_online (priv->notification_proxy, is_online);
diff --git a/calendar/libedata-cal/e-cal-backend.h b/calendar/libedata-cal/e-cal-backend.h
index 981d9fb..73198c6 100644
--- a/calendar/libedata-cal/e-cal-backend.h
+++ b/calendar/libedata-cal/e-cal-backend.h
@@ -23,6 +23,7 @@
 #ifndef E_CAL_BACKEND_H
 #define E_CAL_BACKEND_H
 
+#include <libebackend/e-backend.h>
 #include <libedataserver/e-credentials.h>
 #include <libedataserver/e-source.h>
 #include <libecal/e-cal-util.h>
@@ -129,13 +130,12 @@ struct _ECalBackendCache;
 typedef struct _ECalBackendPrivate ECalBackendPrivate;
 
 struct _ECalBackend {
-	GObject object;
-
+	EBackend parent;
 	ECalBackendPrivate *priv;
 };
 
 struct _ECalBackendClass {
-	GObjectClass parent_class;
+	EBackendClass parent_class;
 
 	/* Virtual methods */
         void	(* get_backend_property)	(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable, const gchar *prop_name);
@@ -143,7 +143,6 @@ struct _ECalBackendClass {
 
 	void	(* open)			(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable, gboolean only_if_exists);
 	void	(* remove)			(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable);
-	void	(* set_online)			(ECalBackend *backend, gboolean is_online);
 	void	(* authenticate_user)		(ECalBackend *backend, GCancellable *cancellable, ECredentials *credentials);
 
 	void	(* refresh)			(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable);
@@ -172,10 +171,7 @@ struct _ECalBackendClass {
 
 GType		e_cal_backend_get_type			(void);
 
-ESource *	e_cal_backend_get_source		(ECalBackend *backend);
-const gchar *	e_cal_backend_get_uri			(ECalBackend *backend);
 icalcomponent_kind e_cal_backend_get_kind		(ECalBackend *backend);
-gboolean	e_cal_backend_is_online			(ECalBackend *backend);
 gboolean	e_cal_backend_is_opened			(ECalBackend *backend);
 gboolean	e_cal_backend_is_opening		(ECalBackend *backend);
 gboolean	e_cal_backend_is_readonly		(ECalBackend *backend);
@@ -197,7 +193,6 @@ void		e_cal_backend_set_notification_proxy	(ECalBackend *backend, ECalBackend *p
 void		e_cal_backend_get_backend_property	(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable, const gchar *prop_name);
 void		e_cal_backend_set_backend_property	(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable, const gchar *prop_name, const gchar *prop_value);
 
-void		e_cal_backend_set_online		(ECalBackend *backend, gboolean is_online);
 void		e_cal_backend_authenticate_user		(ECalBackend *backend, GCancellable *cancellable, ECredentials *credentials);
 
 void		e_cal_backend_open			(ECalBackend *backend, EDataCal *cal, guint32 opid, GCancellable *cancellable, gboolean only_if_exists);
diff --git a/calendar/libedata-cal/e-data-cal-factory.c b/calendar/libedata-cal/e-data-cal-factory.c
index 4413341..806c348 100644
--- a/calendar/libedata-cal/e-data-cal-factory.c
+++ b/calendar/libedata-cal/e-data-cal-factory.c
@@ -34,16 +34,8 @@
 #include <gtk/gtk.h>
 #endif
 
-#ifdef G_OS_UNIX
-#if GLIB_CHECK_VERSION(2,29,5)
-#include <glib-unix.h>
-#endif
-#endif
-
 #include <libedataserver/e-url.h>
 #include <libedataserver/e-source-list.h>
-#include <libebackend/e-data-server-module.h>
-#include <libebackend/e-offline-listener.h>
 #include <libecal/e-cal-client.h>
 #include "e-cal-backend.h"
 #include "e-cal-backend-factory.h"
@@ -73,8 +65,6 @@
 	(G_TYPE_INSTANCE_GET_PRIVATE \
 	((obj), E_TYPE_DATA_CAL_FACTORY, EDataCalFactoryPrivate))
 
-static GMainLoop *loop;
-
 /* Keeps running after the last client is closed. */
 static gboolean opt_keep_running = FALSE;
 
@@ -88,63 +78,25 @@ static gboolean opt_keep_running = FALSE;
 	}								\
 	} G_STMT_END
 
-G_DEFINE_TYPE (EDataCalFactory, e_data_cal_factory, G_TYPE_OBJECT);
+G_DEFINE_TYPE (EDataCalFactory, e_data_cal_factory, E_TYPE_DATA_FACTORY);
 
 struct _EDataCalFactoryPrivate {
 	EGdbusCalFactory *gdbus_object;
 
-	/* Hash table from URI method strings to GType * for backend class types */
-	GHashTable *methods;
-
-	GHashTable *backends;
-	/* mutex to access backends hash table */
-	GMutex *backends_mutex;
-
+	GMutex *calendars_lock;
+	/* A hash of object paths for calendar URIs to EDataCals */
 	GHashTable *calendars;
 
+	GMutex *connections_lock;
+	/* This is a hash of client addresses to GList* of EDataCals */
 	GHashTable *connections;
 
-	gboolean is_online;
-
-	/* this is for notifications of source changes */
-	ESourceList *lists[E_CAL_CLIENT_SOURCE_TYPE_LAST];
-
-	/* backends divided by their type */
-	GList *backends_by_type[E_CAL_CLIENT_SOURCE_TYPE_LAST];
-
 	guint exit_timeout;
 };
 
 /* Forward Declarations */
 void e_data_cal_migrate_basedir (void);
 
-/* Create the EDataCalFactory error quark */
-GQuark
-e_data_cal_factory_error_quark (void)
-{
-	static GQuark quark = 0;
-	if (!quark)
-		quark = g_quark_from_static_string ("e_data_cal_factory_error");
-	return quark;
-}
-
-static icalcomponent_kind
-calobjtype_to_icalkind (const EDataCalObjType type)
-{
-	switch (type) {
-	case Event:
-		return ICAL_VEVENT_COMPONENT;
-	case Todo:
-		return ICAL_VTODO_COMPONENT;
-	case Journal:
-		return ICAL_VJOURNAL_COMPONENT;
-	case AnyType:
-		return ICAL_NO_COMPONENT;
-	}
-
-	return ICAL_NO_COMPONENT;
-}
-
 static const gchar *
 calobjtype_to_string (const EDataCalObjType type)
 {
@@ -159,96 +111,50 @@ calobjtype_to_string (const EDataCalObjType type)
 		break;
 	}
 
-	return "UNKNOWN COMPONENT";
-}
-
-static ECalClientSourceType
-icalkind_to_ecalclientsourcetype (const icalcomponent_kind kind)
-{
-	switch (kind) {
-	case ICAL_VEVENT_COMPONENT:
-		return E_CAL_CLIENT_SOURCE_TYPE_EVENTS;
-	case ICAL_VTODO_COMPONENT:
-		return E_CAL_CLIENT_SOURCE_TYPE_TASKS;
-	case ICAL_VJOURNAL_COMPONENT:
-		return E_CAL_CLIENT_SOURCE_TYPE_MEMOS;
-	default:
-		break;
-	}
-
-	return E_CAL_CLIENT_SOURCE_TYPE_LAST;
+	g_return_val_if_reached (NULL);
 }
 
-static void
-update_source_in_backend (ECalBackend *backend,
-                          ESource *updated_source)
+static gchar *
+e_data_cal_factory_extract_proto_from_uri (const gchar *uri)
 {
-	ESource *backend_source;
-	xmlNodePtr xml;
+	gchar *proto, *cp;
 
-	g_return_if_fail (backend != NULL);
-	g_return_if_fail (updated_source != NULL);
+	cp = strchr (uri, ':');
+	if (cp == NULL)
+		return NULL;
 
-	backend_source = e_cal_backend_get_source (backend);
+	proto = g_malloc0 (cp - uri + 1);
+	strncpy (proto, uri, cp - uri);
 
-	xml = xmlNewNode (NULL, (const xmlChar *) "dummy");
-	e_source_dump_to_xml_node (updated_source, xml);
-	e_source_update_from_xml_node (backend_source, xml->children, NULL);
-	xmlFreeNode (xml);
+	return proto;
 }
 
-static void
-source_list_changed_cb (ESourceList *list,
-                        EDataCalFactory *factory)
+static EBackend *
+e_data_cal_factory_get_backend (EDataCalFactory *factory,
+                                ESource *source,
+                                const gchar *uri,
+                                EDataCalObjType type)
 {
-	EDataCalFactoryPrivate *priv;
-	gint i;
-
-	g_return_if_fail (list != NULL);
-	g_return_if_fail (E_IS_DATA_CAL_FACTORY (factory));
-
-	priv = factory->priv;
-
-	g_mutex_lock (priv->backends_mutex);
-
-	for (i = 0; i < E_CAL_CLIENT_SOURCE_TYPE_LAST; i++) {
-		GList *iter;
+	EBackend *backend;
+	gchar *protocol;
+	gchar *hash_key;
 
-		if (list != priv->lists[i])
-			continue;
-
-		for (iter = priv->backends_by_type[i]; iter; iter = iter->next) {
-			ECalBackend *backend = iter->data;
-			ESource *source, *list_source;
-			const gchar *uid;
-
-			source = e_cal_backend_get_source (backend);
-			uid = e_source_peek_uid (source);
-			list_source = e_source_list_peek_source_by_uid (
-				priv->lists[i], uid);
-
-			if (list_source != NULL)
-				update_source_in_backend (backend, list_source);
-		}
-
-		break;
+	protocol = e_data_cal_factory_extract_proto_from_uri (uri);
+	if (protocol == NULL) {
+		g_warning ("Cannot extract protocol from URI %s", uri);
+		return NULL;
 	}
 
-	g_mutex_unlock (priv->backends_mutex);
-}
+	hash_key = g_strdup_printf (
+		"%s:%s", protocol, calobjtype_to_string (type));
 
-static ECalBackendFactory *
-get_backend_factory (GHashTable *methods,
-                     const gchar *method,
-                     icalcomponent_kind kind)
-{
-	GHashTable *kinds;
+	backend = e_data_factory_get_backend (
+		E_DATA_FACTORY (factory), hash_key, source);
 
-	kinds = g_hash_table_lookup (methods, method);
-	if (kinds == NULL)
-		return NULL;
+	g_free (hash_key);
+	g_free (protocol);
 
-	return g_hash_table_lookup (kinds, GINT_TO_POINTER (kind));
+	return backend;
 }
 
 static gchar *
@@ -307,54 +213,7 @@ calendar_freed_cb (EDataCalFactory *factory,
 	/* If there are no open calendars, start a timer to quit. */
 	if (!opt_keep_running && priv->exit_timeout == 0)
 		priv->exit_timeout = g_timeout_add_seconds (
-			10, (GSourceFunc) g_main_loop_quit, loop);
-}
-
-static void
-last_client_gone_cb (ECalBackend *backend,
-                     EDataCalFactory *factory)
-{
-	EDataCalFactoryPrivate *priv = factory->priv;
-
-	if (e_cal_backend_is_removed (backend)) {
-		g_mutex_lock (priv->backends_mutex);
-		g_hash_table_foreach_remove (
-			priv->backends, remove_dead_calendar_cb, backend);
-		g_mutex_unlock (priv->backends_mutex);
-	}
-}
-
-struct find_backend_data {
-	const gchar *str_uri;
-	ECalBackend *backend;
-	icalcomponent_kind kind;
-};
-
-static void
-find_backend_cb (gpointer key,
-                 gpointer value,
-                 gpointer data)
-{
-	struct find_backend_data *fbd = data;
-
-	if (fbd && fbd->str_uri && !fbd->backend) {
-		ECalBackend *backend = value;
-		ESource *backend_source;
-		gchar *str_uri;
-
-		backend_source = e_cal_backend_get_source (backend);
-		str_uri = e_source_get_uri (backend_source);
-
-		if (str_uri && g_str_equal (str_uri, fbd->str_uri)) {
-			const gchar *uid_kind = key, *pos;
-
-			pos = strrchr (uid_kind, ':');
-			if (pos && atoi (pos + 1) == fbd->kind)
-				fbd->backend = backend;
-		}
-
-		g_free (str_uri);
-	}
+			10, (GSourceFunc) e_dbus_server_quit, factory);
 }
 
 static gboolean
@@ -364,14 +223,11 @@ impl_CalFactory_get_cal (EGdbusCalFactory *object,
                          EDataCalFactory *factory)
 {
 	EDataCal *calendar;
-	ECalBackend *backend;
+	EBackend *backend;
 	EDataCalFactoryPrivate *priv = factory->priv;
-	ECalBackendFactory *backend_factory;
 	GDBusConnection *connection;
 	ESource *source;
-	gchar *str_uri;
-	EUri *uri;
-	gchar *uid_type_string;
+	gchar *uri;
 	gchar *path = NULL;
 	const gchar *sender;
 	GList *list;
@@ -392,133 +248,49 @@ impl_CalFactory_get_cal (EGdbusCalFactory *object,
 	}
 
 	source = e_source_new_from_standalone_xml (source_xml);
-	if (!source) {
-		g_free (source_xml);
+	g_free (source_xml);
 
+	if (!source) {
 		error = g_error_new (
-			E_DATA_CAL_ERROR, NoSuchCal, _("Invalid source"));
+			E_DATA_CAL_ERROR,
+			NoSuchCal,
+			_("Invalid source"));
 		g_dbus_method_invocation_return_gerror (invocation, error);
 		g_error_free (error);
 
 		return TRUE;
 	}
 
-	g_free (source_xml);
+	uri = e_source_get_uri (source);
 
-	/* Get the URI so we can extract the protocol */
-	str_uri = e_source_get_uri (source);
-	if (!str_uri) {
+	if (uri == NULL || *uri == '\0') {
 		g_object_unref (source);
+		g_free (uri);
 
 		error = g_error_new (
-			E_DATA_CAL_ERROR, NoSuchCal, _("Empty URI"));
+			E_DATA_CAL_ERROR,
+			NoSuchCal,
+			_("Empty URI"));
 		g_dbus_method_invocation_return_gerror (invocation, error);
 		g_error_free (error);
 
 		return TRUE;
 	}
 
-	/* Parse the uri */
-	uri = e_uri_new (str_uri);
-	if (!uri) {
-		g_object_unref (source);
-		g_free (str_uri);
+	backend = e_data_cal_factory_get_backend (factory, source, uri, type);
 
+	if (backend == NULL) {
 		error = g_error_new (
-			E_DATA_CAL_ERROR, NoSuchCal, _("Invalid URI"));
+			E_DATA_CAL_ERROR,
+			NoSuchCal,
+			_("Invalid source"));
 		g_dbus_method_invocation_return_gerror (invocation, error);
 		g_error_free (error);
 
 		return TRUE;
 	}
 
-	uid_type_string = g_strdup_printf (
-		"%s:%d", e_source_peek_uid (source),
-		(gint) calobjtype_to_icalkind (type));
-
-	/* Find the associated backend factory (if any) */
-	backend_factory = get_backend_factory (
-		priv->methods, uri->protocol,
-		calobjtype_to_icalkind (type));
-	if (!backend_factory) {
-		error = g_error_new (
-			E_DATA_CAL_ERROR, NoSuchCal,
-			_("No backend factory for '%s' of '%s'"),
-			uri->protocol, calobjtype_to_string (type));
-
-		goto cleanup2;
-	}
-
-	g_mutex_lock (priv->backends_mutex);
-
-	/* Look for an existing backend */
-	backend = g_hash_table_lookup (
-		factory->priv->backends, uid_type_string);
-
-	if (!backend) {
-		/* Find backend by URL, if opened, thus functions like
-		 * e_cal_system_new_* will not create new backends for
-		 * the same URL. */
-		struct find_backend_data fbd;
-
-		fbd.str_uri = str_uri;
-		fbd.kind = calobjtype_to_icalkind (type);
-		fbd.backend = NULL;
-
-		g_hash_table_foreach (priv->backends, find_backend_cb, &fbd);
-
-		if (fbd.backend) {
-			backend = fbd.backend;
-			g_object_unref (source);
-			source = e_cal_backend_get_source (backend);
-			g_object_ref (source);
-		}
-	}
-
-	if (!backend) {
-		ECalClientSourceType st;
-		icalcomponent_kind kind;
-
-		/* There was no existing backend, create a new one */
-		backend = e_cal_backend_factory_new_backend (
-			backend_factory, source);
-
-		if (!backend) {
-			error = g_error_new (
-				E_DATA_CAL_ERROR, NoSuchCal,
-				_("Could not instantiate backend"));
-			goto cleanup;
-		}
-
-		kind = e_cal_backend_get_kind (backend);
-		st = icalkind_to_ecalclientsourcetype (kind);
-		if (st != E_CAL_CLIENT_SOURCE_TYPE_LAST) {
-			if (!priv->lists[st] &&
-			    e_cal_client_get_sources (
-			    &(priv->lists[st]), st, NULL)) {
-				g_signal_connect (
-					priv->lists[st], "changed",
-					G_CALLBACK (source_list_changed_cb),
-					factory);
-			}
-
-			if (priv->lists[st])
-				priv->backends_by_type[st] = g_list_prepend (
-					priv->backends_by_type[st], backend);
-		}
-
-		/* Track the backend */
-		g_hash_table_insert (
-			priv->backends, g_strdup (uid_type_string), backend);
-
-		g_signal_connect (
-			backend, "last-client-gone",
-			G_CALLBACK (last_client_gone_cb), factory);
-		e_cal_backend_set_online (backend, priv->is_online);
-	} else if (!e_source_equal (source, e_cal_backend_get_source (backend))) {
-		/* source changed, update it in a backend */
-		update_source_in_backend (backend, source);
-	}
+	g_mutex_lock (priv->calendars_lock);
 
 	/* Remove a pending exit */
 	if (priv->exit_timeout) {
@@ -526,35 +298,29 @@ impl_CalFactory_get_cal (EGdbusCalFactory *object,
 		priv->exit_timeout = 0;
 	}
 
-	calendar = e_data_cal_new (backend, source);
-	e_cal_backend_add_client (backend, calendar);
-
 	path = construct_cal_factory_path ();
+	calendar = e_data_cal_new (E_CAL_BACKEND (backend));
+	g_hash_table_insert (priv->calendars, g_strdup (path), calendar);
+	e_cal_backend_add_client (E_CAL_BACKEND (backend), calendar);
 	e_data_cal_register_gdbus_object (calendar, connection, path, &error);
 	g_object_weak_ref (
 		G_OBJECT (calendar), (GWeakNotify)
 		calendar_freed_cb, factory);
 
-	g_hash_table_insert (priv->calendars, g_strdup (path), calendar);
-
+	/* Update the hash of open connections. */
+	g_mutex_lock (priv->connections_lock);
 	list = g_hash_table_lookup (priv->connections, sender);
 	list = g_list_prepend (list, calendar);
 	g_hash_table_insert (priv->connections, g_strdup (sender), list);
+	g_mutex_unlock (priv->connections_lock);
+
+	g_mutex_unlock (priv->calendars_lock);
 
-cleanup:
-	/* The reason why the lock is held for such a long time is that there is
-	 * a subtle race where e_cal_backend_add_client () can be called just
-	 * before e_cal_backend_finalize () is called from the
-	 * backend_last_client_gone_cb (), for details see bug 506457. */
-	g_mutex_unlock (priv->backends_mutex);
-
-cleanup2:
-	g_free (str_uri);
-	e_uri_free (uri);
-	g_free (uid_type_string);
 	g_object_unref (source);
+	g_free (uri);
 
-	e_gdbus_cal_factory_complete_get_cal (object, invocation, path, error);
+	e_gdbus_cal_factory_complete_get_cal (
+		object, invocation, path, error);
 
 	if (error)
 		g_error_free (error);
@@ -565,13 +331,10 @@ cleanup2:
 }
 
 static void
-remove_data_cal_cb (gpointer data_cl,
-                    gpointer user_data)
+remove_data_cal_cb (EDataCal *data_cal)
 {
 	ECalBackend *backend;
-	EDataCal *data_cal;
 
-	data_cal = E_DATA_CAL (data_cl);
 	g_return_if_fail (data_cal != NULL);
 
 	backend = e_data_cal_get_backend (data_cal);
@@ -581,21 +344,9 @@ remove_data_cal_cb (gpointer data_cl,
 }
 
 static void
-unref_backend_cb (gpointer key,
-                  gpointer value,
-                  gpointer user_data)
-{
-	ECalBackend *backend = value;
-
-	if (backend)
-		g_object_unref (backend);
-}
-
-static void
 e_data_cal_factory_dispose (GObject *object)
 {
 	EDataCalFactoryPrivate *priv;
-	gint ii;
 
 	priv = E_DATA_CAL_FACTORY_GET_PRIVATE (object);
 
@@ -604,16 +355,6 @@ e_data_cal_factory_dispose (GObject *object)
 		priv->gdbus_object = NULL;
 	}
 
-	for (ii = 0; ii < E_CAL_CLIENT_SOURCE_TYPE_LAST; ii++) {
-		if (priv->lists[ii] != NULL) {
-			g_object_unref (priv->lists[ii]);
-			priv->lists[ii] = NULL;
-		}
-
-		g_list_free (priv->backends_by_type[ii]);
-		priv->backends_by_type[ii] = NULL;
-	}
-
 	/* Chain up to parent's dispose() method. */
 	G_OBJECT_CLASS (e_data_cal_factory_parent_class)->dispose (object);
 }
@@ -625,368 +366,121 @@ e_data_cal_factory_finalize (GObject *object)
 
 	priv = E_DATA_CAL_FACTORY_GET_PRIVATE (object);
 
-	g_hash_table_foreach (priv->backends, unref_backend_cb, NULL);
-
-	g_hash_table_destroy (priv->methods);
-	g_hash_table_destroy (priv->backends);
 	g_hash_table_destroy (priv->calendars);
 	g_hash_table_destroy (priv->connections);
 
-	g_mutex_free (priv->backends_mutex);
+	g_mutex_free (priv->calendars_lock);
+	g_mutex_free (priv->connections_lock);
 
 	/* Chain up to parent's finalize() method. */
 	G_OBJECT_CLASS (e_data_cal_factory_parent_class)->finalize (object);
 }
 
-/* Class initialization function for the calendar factory */
 static void
-e_data_cal_factory_class_init (EDataCalFactoryClass *class)
-{
-	GObjectClass *object_class;
-
-	g_type_class_add_private (class, sizeof (EDataCalFactoryPrivate));
-
-	object_class = G_OBJECT_CLASS (class);
-	object_class->dispose = e_data_cal_factory_dispose;
-	object_class->finalize = e_data_cal_factory_finalize;
-}
-
-static void
-e_data_cal_factory_init (EDataCalFactory *factory)
-{
-	GError *error = NULL;
-
-	factory->priv = E_DATA_CAL_FACTORY_GET_PRIVATE (factory);
-
-	factory->priv->gdbus_object = e_gdbus_cal_factory_stub_new ();
-	g_signal_connect (
-		factory->priv->gdbus_object, "handle-get-cal",
-		G_CALLBACK (impl_CalFactory_get_cal), factory);
-
-	factory->priv->methods = g_hash_table_new_full (
-		g_str_hash, g_str_equal,
-		(GDestroyNotify) g_free,
-		(GDestroyNotify) g_hash_table_destroy);
-
-	factory->priv->backends_mutex = g_mutex_new ();
-
-	factory->priv->backends = g_hash_table_new_full (
-		g_str_hash, g_str_equal,
-		(GDestroyNotify) g_free,
-		(GDestroyNotify) NULL);
-
-	factory->priv->calendars = g_hash_table_new_full (
-		g_str_hash, g_str_equal,
-		(GDestroyNotify) g_free,
-		(GDestroyNotify) NULL);
-
-	factory->priv->connections = g_hash_table_new_full (
-		g_str_hash, g_str_equal,
-		(GDestroyNotify) g_free,
-		(GDestroyNotify) NULL);
-
-	if (!e_data_server_module_init (BACKENDDIR, &error))
-		g_error ("%s", error->message);
-
-	e_data_cal_factory_register_backends (factory);
-}
-
-static guint
-e_data_cal_factory_register_gdbus_object (EDataCalFactory *factory,
-                                          GDBusConnection *connection,
-                                          const gchar *object_path,
-                                          GError **error)
+data_cal_factory_bus_acquired (EDBusServer *server,
+                               GDBusConnection *connection)
 {
-	g_return_val_if_fail (E_IS_DATA_CAL_FACTORY (factory), 0);
-	g_return_val_if_fail (connection != NULL, 0);
-	g_return_val_if_fail (object_path != NULL, 0);
-
-	return e_gdbus_cal_factory_register_object (
-		factory->priv->gdbus_object, connection, object_path, error);
-}
-
-/**
- * e_data_cal_factory_set_backend_online:
- * @factory: A calendar factory.
- * @is_online: Online mode to set.
- *
- * Sets the online mode for all backends created by the given factory.
- *
- * Since: 3.2
- */
-void
-e_data_cal_factory_set_backend_online (EDataCalFactory *factory,
-                                       gboolean is_online)
-{
-	GHashTableIter iter;
-	gpointer value;
-
-	g_return_if_fail (E_IS_DATA_CAL_FACTORY (factory));
-
-	factory->priv->is_online = is_online;
-	g_mutex_lock (factory->priv->backends_mutex);
-
-	g_hash_table_iter_init (&iter, factory->priv->backends);
-	while (g_hash_table_iter_next (&iter, NULL, &value))
-		e_cal_backend_set_online (
-			E_CAL_BACKEND (value),
-			factory->priv->is_online);
-
-	g_mutex_unlock (factory->priv->backends_mutex);
-}
-
-/**
- * e_data_cal_factory_register_backend:
- * @factory: A calendar factory.
- * @backend_factory: The object responsible for creating backends.
- *
- * Registers an #ECalBackend subclass that will be used to handle URIs
- * with a particular method.  When the factory is asked to open a
- * particular URI, it will look in its list of registered methods and
- * create a backend of the appropriate type.
- **/
-void
-e_data_cal_factory_register_backend (EDataCalFactory *factory,
-                                     ECalBackendFactory *backend_factory)
-{
-	ECalBackendFactoryClass *class;
 	EDataCalFactoryPrivate *priv;
-	const gchar *method;
-	GHashTable *kinds;
-	GType type;
-	icalcomponent_kind kind;
-	GList *methods = NULL, *l;
-
-	g_return_if_fail (E_IS_DATA_CAL_FACTORY (factory));
-	g_return_if_fail (E_IS_CAL_BACKEND_FACTORY (backend_factory));
-
-	priv = factory->priv;
-
-	class = E_CAL_BACKEND_FACTORY_GET_CLASS (backend_factory);
-	g_return_if_fail (class->get_protocol != NULL);
-
-	method = class->get_protocol (backend_factory);
-	methods = g_list_append (methods, (gpointer) method);
-
-	kind = class->get_kind (backend_factory);
-
-	for (l = methods; l != NULL; l = g_list_next (l)) {
-		gchar *method_str;
-
-		method = l->data;
-
-		method_str = g_ascii_strdown (method, -1);
-
-		kinds = g_hash_table_lookup (priv->methods, method_str);
-		if (kinds) {
-			gpointer data;
-
-			data = GINT_TO_POINTER (kind);
-			data = g_hash_table_lookup (kinds, data);
-			type = GPOINTER_TO_INT (data);
-
-			if (type) {
-				g_warning (
-					G_STRLOC ": method '%s' "
-					"already registered", method_str);
-				g_free (method_str);
-				g_list_free (methods);
-				return;
-			}
-
-			g_free (method_str);
-		} else {
-			kinds = g_hash_table_new_full (
-				g_direct_hash, g_direct_equal, NULL, NULL);
-			g_hash_table_insert (priv->methods, method_str, kinds);
-		}
-
-		g_hash_table_insert (
-			kinds, GINT_TO_POINTER (kind), backend_factory);
-	}
-	g_list_free (methods);
-}
-
-/**
- * e_data_cal_factory_register_backends:
- * @cal_factory: A calendar factory.
- *
- * Register all backends for the given factory.
- */
-void
-e_data_cal_factory_register_backends (EDataCalFactory *cal_factory)
-{
-	GType type;
-	GList *factories;
-	GList *iter;
-
-	g_return_if_fail (E_IS_DATA_CAL_FACTORY (cal_factory));
+	guint registration_id;
+	GError *error = NULL;
 
-	type = E_TYPE_CAL_BACKEND_FACTORY;
-	factories = e_data_server_get_extensions_for_type (type);
+	priv = E_DATA_CAL_FACTORY_GET_PRIVATE (server);
 
-	for (iter = factories; iter != NULL; iter = g_list_next (iter)) {
-		ECalBackendFactory *backend_factory = iter->data;
+	registration_id = e_gdbus_cal_factory_register_object (
+		priv->gdbus_object,
+		connection,
+		"/org/gnome/evolution/dataserver/CalendarFactory",
+		&error);
 
-		e_data_cal_factory_register_backend (
-			cal_factory, g_object_ref (backend_factory));
+	if (error != NULL) {
+		g_error (
+			"Failed to register a CalendarFactory object: %s",
+			error->message);
+		g_assert_not_reached ();
 	}
 
-	e_data_server_extension_list_free (factories);
-	e_data_server_module_remove_unused ();
-}
-
-/**
- * e_data_cal_factory_get_n_backends
- * @factory: A calendar factory.
- *
- * Get the number of backends currently active in the given factory.
- *
- * Returns: the number of backends.
- */
-guint
-e_data_cal_factory_get_n_backends (EDataCalFactory *factory)
-{
-	EDataCalFactoryPrivate *priv;
-	guint n_backends;
-
-	g_return_val_if_fail (E_IS_DATA_CAL_FACTORY (factory), 0);
-
-	priv = factory->priv;
-	g_mutex_lock (priv->backends_mutex);
-	n_backends = g_hash_table_size (priv->backends);
-	g_mutex_unlock (priv->backends_mutex);
+	g_assert (registration_id > 0);
 
-	return n_backends;
+	/* Chain up to parent's bus_acquired() method. */
+	E_DBUS_SERVER_CLASS (e_data_cal_factory_parent_class)->
+		bus_acquired (server, connection);
 }
 
-/* Frees a uri/backend pair from the backends hash table */
 static void
-dump_backend (gpointer key,
-              gpointer value,
-              gpointer data)
-{
-	gchar *uri;
-	ECalBackend *backend;
-
-	uri = key;
-	backend = value;
-
-	g_message ("  %s: %p", uri, (gpointer) backend);
-}
-
-/**
- * e_data_cal_factory_dump_active_backends:
- * @factory: A calendar factory.
- *
- * Dumps to standard output a list of all active backends for the given
- * factory.
- */
-void
-e_data_cal_factory_dump_active_backends (EDataCalFactory *factory)
+data_cal_factory_bus_name_lost (EDBusServer *server,
+                                GDBusConnection *connection)
 {
 	EDataCalFactoryPrivate *priv;
+	GList *list = NULL;
+	gchar *key;
 
-	g_message ("Active PCS backends");
+	priv = E_DATA_CAL_FACTORY_GET_PRIVATE (server);
 
-	priv = factory->priv;
-	g_mutex_lock (priv->backends_mutex);
-	g_hash_table_foreach (priv->backends, dump_backend, NULL);
-	g_mutex_unlock (priv->backends_mutex);
-}
+	g_mutex_lock (priv->connections_lock);
 
-/* Convenience function to print an error and exit */
-G_GNUC_NORETURN static void
-die (const gchar *prefix,
-     GError *error)
-{
-	g_error ("%s: %s", prefix, error->message);
-	g_error_free (error);
-	exit (1);
-}
+	while (g_hash_table_lookup_extended (
+		priv->connections,
+		CALENDAR_DBUS_SERVICE_NAME,
+		(gpointer) &key, (gpointer) &list)) {
+		GList *copy;
 
-static void
-offline_state_changed_cb (EOfflineListener *eol,
-                          EDataCalFactory *factory)
-{
-	switch (e_offline_listener_get_state (eol)) {
-		case EOL_STATE_OFFLINE:
-			e_data_cal_factory_set_backend_online (factory, FALSE);
-			break;
-		case EOL_STATE_ONLINE:
-			e_data_cal_factory_set_backend_online (factory, TRUE);
-			break;
-		default:
-			g_warn_if_reached ();
+		/* this should trigger the calendar's weak ref notify
+		 * function, which will remove it from the list before
+		 * it's freed, and will remove the connection from
+		 * priv->connections once they're all gone */
+		copy = g_list_copy (list);
+		g_list_foreach (copy, (GFunc) remove_data_cal_cb, NULL);
+		g_list_free (copy);
 	}
+
+	g_mutex_unlock (priv->connections_lock);
+
+	/* Chain up to parent's bus_name_lost() method. */
+	E_DBUS_SERVER_CLASS (e_data_cal_factory_parent_class)->
+		bus_name_lost (server, connection);
 }
 
 static void
-on_bus_acquired (GDBusConnection *connection,
-                 const gchar *name,
-                 gpointer user_data)
+e_data_cal_factory_class_init (EDataCalFactoryClass *class)
 {
-	EDataCalFactory *factory = user_data;
-	guint registration_id;
-	GError *error = NULL;
-
-	registration_id = e_data_cal_factory_register_gdbus_object (
-		factory,
-		connection,
-		"/org/gnome/evolution/dataserver/CalendarFactory",
-		&error);
+	GObjectClass *object_class;
+	EDBusServerClass *dbus_server_class;
 
-	if (error)
-		die ("Failed to register a CalendarFactory object", error);
+	g_type_class_add_private (class, sizeof (EDataCalFactoryPrivate));
 
-	g_assert (registration_id > 0);
-}
+	object_class = G_OBJECT_CLASS (class);
+	object_class->dispose = e_data_cal_factory_dispose;
+	object_class->finalize = e_data_cal_factory_finalize;
 
-static void
-on_name_acquired (GDBusConnection *connection,
-                  const gchar *name,
-                  gpointer user_data)
-{
+	dbus_server_class = E_DBUS_SERVER_CLASS (class);
+	dbus_server_class->bus_name = CALENDAR_DBUS_SERVICE_NAME;
+	dbus_server_class->module_directory = BACKENDDIR;
+	dbus_server_class->bus_acquired = data_cal_factory_bus_acquired;
+	dbus_server_class->bus_name_lost = data_cal_factory_bus_name_lost;
 }
 
 static void
-on_name_lost (GDBusConnection *connection,
-              const gchar *name,
-              gpointer user_data)
+e_data_cal_factory_init (EDataCalFactory *factory)
 {
-	GList *list = NULL;
-	gchar *key;
-	EDataCalFactory *factory = user_data;
-
-	while (g_hash_table_lookup_extended (
-		factory->priv->connections, name,
-		(gpointer) &key, (gpointer) &list)) {
-
-		GList *copy = g_list_copy (list);
+	factory->priv = E_DATA_CAL_FACTORY_GET_PRIVATE (factory);
 
-		/* this should trigger the book's weak ref notify
-		 * function, which will remove it from the list before
-		 * it's freed, and will remove the connection from
-		 * priv->connections once they're all gone */
-		g_list_foreach (copy, remove_data_cal_cb, NULL);
-		g_list_free (copy);
-	}
-	g_print ("Superseded...\n");
-	g_main_loop_quit (loop);
-}
+	factory->priv->gdbus_object = e_gdbus_cal_factory_stub_new ();
+	g_signal_connect (
+		factory->priv->gdbus_object, "handle-get-cal",
+		G_CALLBACK (impl_CalFactory_get_cal), factory);
 
-#ifdef G_OS_UNIX
-#if GLIB_CHECK_VERSION(2,29,5)
-static gboolean
-handle_term_signal (gpointer data)
-{
-	g_print ("Received terminate signal...\n");
-	g_main_loop_quit (loop);
+	factory->priv->calendars_lock = g_mutex_new ();
+	factory->priv->calendars = g_hash_table_new_full (
+		g_str_hash, g_str_equal,
+		(GDestroyNotify) g_free,
+		(GDestroyNotify) NULL);
 
-	return FALSE;
+	factory->priv->connections_lock = g_mutex_new ();
+	factory->priv->connections = g_hash_table_new_full (
+		g_str_hash, g_str_equal,
+		(GDestroyNotify) g_free,
+		(GDestroyNotify) NULL);
 }
-#endif
-#endif
 
 static GOptionEntry entries[] = {
 
@@ -1002,10 +496,8 @@ gint
 main (gint argc,
       gchar **argv)
 {
-	EOfflineListener *eol;
 	GOptionContext *context;
-	EDataCalFactory *factory;
-	guint owner_id;
+	EDBusServer *server;
 	GError *error = NULL;
 
 #ifdef G_OS_WIN32
@@ -1057,48 +549,22 @@ main (gint argc,
 	ical_set_unknown_token_handling_setting (ICAL_DISCARD_TOKEN);
 #endif
 
-	factory = g_object_new (E_TYPE_DATA_CAL_FACTORY, NULL);
-
-	loop = g_main_loop_new (NULL, FALSE);
-
-	eol = e_offline_listener_new ();
-	offline_state_changed_cb (eol, factory);
-	g_signal_connect (
-		eol, "changed",
-		G_CALLBACK (offline_state_changed_cb), factory);
-
-	owner_id = g_bus_own_name (
-		G_BUS_TYPE_SESSION,
-		CALENDAR_DBUS_SERVICE_NAME,
-		G_BUS_NAME_OWNER_FLAGS_REPLACE | G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
-		on_bus_acquired,
-		on_name_acquired,
-		on_name_lost,
-		factory,
-		NULL);
-
 	/* Migrate user data from ~/.evolution to XDG base directories. */
 	e_data_cal_migrate_basedir ();
 
-#ifdef G_OS_UNIX
-#if GLIB_CHECK_VERSION(2,29,19)
-	g_unix_signal_add_full (
-		G_PRIORITY_DEFAULT, SIGTERM,
-		handle_term_signal, NULL, NULL);
-#elif GLIB_CHECK_VERSION(2,29,5)
-	g_unix_signal_add_watch_full (
-		SIGTERM, G_PRIORITY_DEFAULT,
-		handle_term_signal, NULL, NULL);
-#endif
-#endif
+	server = g_initable_new (
+		E_TYPE_DATA_CAL_FACTORY, NULL, &error, NULL);
+
+	if (error != NULL) {
+		g_printerr ("%s\n", error->message);
+		exit (EXIT_FAILURE);
+	}
 
 	g_print ("Server is up and running...\n");
 
-	g_main_loop_run (loop);
+	e_dbus_server_run (server);
 
-	g_bus_unown_name (owner_id);
-	g_object_unref (eol);
-	g_object_unref (factory);
+	g_object_unref (server);
 
 	g_print ("Bye.\n");
 
diff --git a/calendar/libedata-cal/e-data-cal-factory.h b/calendar/libedata-cal/e-data-cal-factory.h
index 81c6270..6026df2 100644
--- a/calendar/libedata-cal/e-data-cal-factory.h
+++ b/calendar/libedata-cal/e-data-cal-factory.h
@@ -22,49 +22,44 @@
 #ifndef E_DATA_CAL_FACTORY_H
 #define E_DATA_CAL_FACTORY_H
 
-#include <glib-object.h>
+#include <libebackend/e-data-factory.h>
 
-G_BEGIN_DECLS
-
-
+/* Standard GObject macros */
+#define E_TYPE_DATA_CAL_FACTORY \
+	(e_data_cal_factory_get_type ())
+#define E_DATA_CAL_FACTORY(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_DATA_CAL_FACTORY, EDataCalFactory))
+#define E_DATA_CAL_FACTORY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_DATA_CAL_FACTORY,  EDataCalFactoryClass))
+#define E_IS_DATA_CAL_FACTORY(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_DATA_CAL_FACTORY))
+#define E_IS_DATA_CAL_FACTORY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_DATA_CAL_FACTORY))
+#define E_DATA_CAL_FACTORY_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_DATA_CAL_FACTORY, EDataCalFactoryClass))
 
-#define E_TYPE_DATA_CAL_FACTORY            (e_data_cal_factory_get_type ())
-#define E_DATA_CAL_FACTORY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), E_TYPE_DATA_CAL_FACTORY, EDataCalFactory))
-#define E_DATA_CAL_FACTORY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), E_TYPE_DATA_CAL_FACTORY,  EDataCalFactoryClass))
-#define E_IS_DATA_CAL_FACTORY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), E_TYPE_DATA_CAL_FACTORY))
-#define E_IS_DATA_CAL_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), E_TYPE_DATA_CAL_FACTORY))
+G_BEGIN_DECLS
 
 typedef struct _EDataCalFactory EDataCalFactory;
 typedef struct _EDataCalFactoryClass EDataCalFactoryClass;
-
 typedef struct _EDataCalFactoryPrivate EDataCalFactoryPrivate;
 
 struct _EDataCalFactory {
-	GObject parent;
+	EDataFactory parent;
 	EDataCalFactoryPrivate *priv;
 };
 
 struct _EDataCalFactoryClass {
-	GObjectClass parent_class;
+	EDataFactoryClass parent_class;
 };
 
-typedef enum {
-	E_DATA_CAL_FACTORY_ERROR_GENERIC
-} EDataCalFactoryError;
-
-GQuark e_data_cal_factory_error_quark (void);
-#define E_DATA_CAL_FACTORY_ERROR e_data_cal_factory_error_quark ()
-
-GType	e_data_cal_factory_get_type        (void);
-
-void	e_data_cal_factory_register_backend	(EDataCalFactory *factory,
-						 ECalBackendFactory *backend_factory);
-void	e_data_cal_factory_register_backends	(EDataCalFactory *factory);
-guint	e_data_cal_factory_get_n_backends	(EDataCalFactory *factory);
-void	e_data_cal_factory_dump_active_backends	(EDataCalFactory *factory);
-void	e_data_cal_factory_set_backend_online	(EDataCalFactory *factory,
-						 gboolean is_online);
+GType	e_data_cal_factory_get_type		(void);
 
 G_END_DECLS
 
-#endif
+#endif /* E_DATA_CAL_FACTORY_H */
diff --git a/calendar/libedata-cal/e-data-cal.c b/calendar/libedata-cal/e-data-cal.c
index 20ced15..b78fa98 100644
--- a/calendar/libedata-cal/e-data-cal.c
+++ b/calendar/libedata-cal/e-data-cal.c
@@ -38,7 +38,9 @@
 #include "e-data-cal-enumtypes.h"
 #include "e-gdbus-cal.h"
 
-G_DEFINE_TYPE (EDataCal, e_data_cal, G_TYPE_OBJECT);
+#define E_DATA_CAL_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_DATA_CAL, EDataCalPrivate))
 
 #define EDC_ERROR(_code) e_data_cal_create_error (_code, NULL)
 #define EDC_ERROR_EX(_code, _msg) e_data_cal_create_error (_code, _msg)
@@ -47,12 +49,16 @@ struct _EDataCalPrivate {
 	EGdbusCal *gdbus_object;
 
 	ECalBackend *backend;
-	ESource *source;
 
 	GStaticRecMutex pending_ops_lock;
 	GHashTable *pending_ops; /* opid to GCancellable for still running operations */
 };
 
+enum {
+	PROP_0,
+	PROP_BACKEND
+};
+
 static EOperationPool *ops_pool = NULL;
 
 typedef enum {
@@ -149,6 +155,8 @@ typedef struct {
 	} d;
 } OperationData;
 
+G_DEFINE_TYPE (EDataCal, e_data_cal, G_TYPE_OBJECT);
+
 /* Function to get a new EDataCalView path, used by get_view below */
 static gchar *
 construct_calview_path (void)
@@ -513,41 +521,6 @@ data_cal_return_error (GDBusMethodInvocation *invocation,
 	g_error_free (error);
 }
 
-EDataCal *
-e_data_cal_new (ECalBackend *backend,
-                ESource *source)
-{
-	EDataCal *cal;
-
-	cal = g_object_new (E_TYPE_DATA_CAL, NULL);
-	cal->priv->backend = g_object_ref (backend);
-	cal->priv->source = g_object_ref (source);
-
-	return cal;
-}
-
-/**
- * e_data_cal_get_source:
- * @cal: an #EDataCal
- *
- * Returns the #ESource for @cal.
- *
- * Returns: the #ESource for @cal
- *
- * Since: 2.30
- **/
-ESource *
-e_data_cal_get_source (EDataCal *cal)
-{
-	return cal->priv->source;
-}
-
-ECalBackend *
-e_data_cal_get_backend (EDataCal *cal)
-{
-	return cal->priv->backend;
-}
-
 /**
  * e_data_cal_register_gdbus_object:
  *
@@ -1641,86 +1614,90 @@ e_data_cal_report_backend_property_changed (EDataCal *cal,
 	g_strfreev (strv);
 }
 
-/* Instance init */
 static void
-e_data_cal_init (EDataCal *ecal)
+data_cal_set_backend (EDataCal *cal,
+                      ECalBackend *backend)
 {
-	EGdbusCal *gdbus_object;
+	g_return_if_fail (E_IS_CAL_BACKEND (backend));
+	g_return_if_fail (cal->priv->backend == NULL);
 
-	ecal->priv = G_TYPE_INSTANCE_GET_PRIVATE (ecal, E_TYPE_DATA_CAL, EDataCalPrivate);
+	cal->priv->backend = g_object_ref (backend);
+}
 
-	ecal->priv->gdbus_object = e_gdbus_cal_stub_new ();
-	ecal->priv->pending_ops = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_object_unref);
-	g_static_rec_mutex_init (&ecal->priv->pending_ops_lock);
+static void
+data_cal_set_property (GObject *object,
+                       guint property_id,
+                       const GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_BACKEND:
+			data_cal_set_backend (
+				E_DATA_CAL (object),
+				g_value_get_object (value));
+			return;
+	}
 
-	gdbus_object = ecal->priv->gdbus_object;
-	g_signal_connect (gdbus_object, "handle-open", G_CALLBACK (impl_Cal_open), ecal);
-	g_signal_connect (gdbus_object, "handle-authenticate-user", G_CALLBACK (impl_Cal_authenticate_user), ecal);
-	g_signal_connect (gdbus_object, "handle-remove", G_CALLBACK (impl_Cal_remove), ecal);
-	g_signal_connect (gdbus_object, "handle-refresh", G_CALLBACK (impl_Cal_refresh), ecal);
-	g_signal_connect (gdbus_object, "handle-get-backend-property", G_CALLBACK (impl_Cal_get_backend_property), ecal);
-	g_signal_connect (gdbus_object, "handle-set-backend-property", G_CALLBACK (impl_Cal_set_backend_property), ecal);
-	g_signal_connect (gdbus_object, "handle-get-object", G_CALLBACK (impl_Cal_get_object), ecal);
-	g_signal_connect (gdbus_object, "handle-get-object-list", G_CALLBACK (impl_Cal_get_object_list), ecal);
-	g_signal_connect (gdbus_object, "handle-get-free-busy", G_CALLBACK (impl_Cal_get_free_busy), ecal);
-	g_signal_connect (gdbus_object, "handle-create-object", G_CALLBACK (impl_Cal_create_object), ecal);
-	g_signal_connect (gdbus_object, "handle-modify-object", G_CALLBACK (impl_Cal_modify_object), ecal);
-	g_signal_connect (gdbus_object, "handle-remove-object", G_CALLBACK (impl_Cal_remove_object), ecal);
-	g_signal_connect (gdbus_object, "handle-receive-objects", G_CALLBACK (impl_Cal_receive_objects), ecal);
-	g_signal_connect (gdbus_object, "handle-send-objects", G_CALLBACK (impl_Cal_send_objects), ecal);
-	g_signal_connect (gdbus_object, "handle-get-attachment-uris", G_CALLBACK (impl_Cal_get_attachment_uris), ecal);
-	g_signal_connect (gdbus_object, "handle-discard-alarm", G_CALLBACK (impl_Cal_discard_alarm), ecal);
-	g_signal_connect (gdbus_object, "handle-get-view", G_CALLBACK (impl_Cal_get_view), ecal);
-	g_signal_connect (gdbus_object, "handle-get-timezone", G_CALLBACK (impl_Cal_get_timezone), ecal);
-	g_signal_connect (gdbus_object, "handle-add-timezone", G_CALLBACK (impl_Cal_add_timezone), ecal);
-	g_signal_connect (gdbus_object, "handle-cancel-operation", G_CALLBACK (impl_Cal_cancel_operation), ecal);
-	g_signal_connect (gdbus_object, "handle-cancel-all", G_CALLBACK (impl_Cal_cancel_all), ecal);
-	g_signal_connect (gdbus_object, "handle-close", G_CALLBACK (impl_Cal_close), ecal);
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+data_cal_get_property (GObject *object,
+                       guint property_id,
+                       GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_BACKEND:
+			g_value_set_object (
+				value,
+				e_data_cal_get_backend (
+				E_DATA_CAL (object)));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 }
 
 static void
 data_cal_dispose (GObject *object)
 {
-	EDataCal *cal = E_DATA_CAL (object);
+	EDataCalPrivate *priv;
 
-	g_return_if_fail (cal != NULL);
-
-	if (cal->priv->backend) {
-		g_object_unref (cal->priv->backend);
-		cal->priv->backend = NULL;
-	}
+	priv = E_DATA_CAL_GET_PRIVATE (object);
 
-	if (cal->priv->source) {
-		g_object_unref (cal->priv->source);
-		cal->priv->source = NULL;
+	if (priv->backend) {
+		g_object_unref (priv->backend);
+		priv->backend = NULL;
 	}
 
+	/* Chain up to parent's dispose() method. */
 	G_OBJECT_CLASS (e_data_cal_parent_class)->dispose (object);
 }
 
 static void
 data_cal_finalize (GObject *object)
 {
-	EDataCal *cal = E_DATA_CAL (object);
+	EDataCalPrivate *priv;
 
-	g_return_if_fail (cal != NULL);
+	priv = E_DATA_CAL_GET_PRIVATE (object);
 
-	if (cal->priv->pending_ops) {
-		g_hash_table_destroy (cal->priv->pending_ops);
-		cal->priv->pending_ops = NULL;
+	if (priv->pending_ops) {
+		g_hash_table_destroy (priv->pending_ops);
+		priv->pending_ops = NULL;
 	}
 
-	g_static_rec_mutex_free (&cal->priv->pending_ops_lock);
+	g_static_rec_mutex_free (&priv->pending_ops_lock);
 
-	if (cal->priv->gdbus_object) {
-		g_object_unref (cal->priv->gdbus_object);
-		cal->priv->gdbus_object = NULL;
+	if (priv->gdbus_object) {
+		g_object_unref (priv->gdbus_object);
+		priv->gdbus_object = NULL;
 	}
 
+	/* Chain up to parent's finalize() method. */
 	G_OBJECT_CLASS (e_data_cal_parent_class)->finalize (object);
 }
 
-/* Class init */
 static void
 e_data_cal_class_init (EDataCalClass *klass)
 {
@@ -1729,9 +1706,121 @@ e_data_cal_class_init (EDataCalClass *klass)
 	g_type_class_add_private (klass, sizeof (EDataCalPrivate));
 
 	object_class = G_OBJECT_CLASS (klass);
+	object_class->set_property = data_cal_set_property;
+	object_class->get_property = data_cal_get_property;
 	object_class->dispose = data_cal_dispose;
 	object_class->finalize = data_cal_finalize;
 
+	g_object_class_install_property (
+		object_class,
+		PROP_BACKEND,
+		g_param_spec_object (
+			"backend",
+			"Backend",
+			"The backend driving this connection",
+			E_TYPE_CAL_BACKEND,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT_ONLY |
+			G_PARAM_STATIC_STRINGS));
+
 	if (!ops_pool)
 		ops_pool = e_operation_pool_new (10, operation_thread, NULL);
 }
+
+static void
+e_data_cal_init (EDataCal *ecal)
+{
+	EGdbusCal *gdbus_object;
+
+	ecal->priv = E_DATA_CAL_GET_PRIVATE (ecal);
+
+	ecal->priv->gdbus_object = e_gdbus_cal_stub_new ();
+	ecal->priv->pending_ops = g_hash_table_new_full (
+		g_direct_hash, g_direct_equal, NULL, g_object_unref);
+	g_static_rec_mutex_init (&ecal->priv->pending_ops_lock);
+
+	gdbus_object = ecal->priv->gdbus_object;
+	g_signal_connect (
+		gdbus_object, "handle-open",
+		G_CALLBACK (impl_Cal_open), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-authenticate-user",
+		G_CALLBACK (impl_Cal_authenticate_user), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-remove",
+		G_CALLBACK (impl_Cal_remove), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-refresh",
+		G_CALLBACK (impl_Cal_refresh), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-backend-property",
+		G_CALLBACK (impl_Cal_get_backend_property), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-set-backend-property",
+		G_CALLBACK (impl_Cal_set_backend_property), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-object",
+		G_CALLBACK (impl_Cal_get_object), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-object-list",
+		G_CALLBACK (impl_Cal_get_object_list), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-free-busy",
+		G_CALLBACK (impl_Cal_get_free_busy), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-create-object",
+		G_CALLBACK (impl_Cal_create_object), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-modify-object",
+		G_CALLBACK (impl_Cal_modify_object), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-remove-object",
+		G_CALLBACK (impl_Cal_remove_object), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-receive-objects",
+		G_CALLBACK (impl_Cal_receive_objects), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-send-objects",
+		G_CALLBACK (impl_Cal_send_objects), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-attachment-uris",
+		G_CALLBACK (impl_Cal_get_attachment_uris), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-discard-alarm",
+		G_CALLBACK (impl_Cal_discard_alarm), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-view",
+		G_CALLBACK (impl_Cal_get_view), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-get-timezone",
+		G_CALLBACK (impl_Cal_get_timezone), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-add-timezone",
+		G_CALLBACK (impl_Cal_add_timezone), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-cancel-operation",
+		G_CALLBACK (impl_Cal_cancel_operation), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-cancel-all",
+		G_CALLBACK (impl_Cal_cancel_all), ecal);
+	g_signal_connect (
+		gdbus_object, "handle-close",
+		G_CALLBACK (impl_Cal_close), ecal);
+}
+
+EDataCal *
+e_data_cal_new (ECalBackend *backend)
+{
+	g_return_val_if_fail (E_IS_CAL_BACKEND (backend), NULL);
+
+	return g_object_new (E_TYPE_DATA_CAL, "backend", backend, NULL);
+}
+
+ECalBackend *
+e_data_cal_get_backend (EDataCal *cal)
+{
+	g_return_val_if_fail (E_IS_DATA_CAL (cal), NULL);
+
+	return cal->priv->backend;
+}
+
diff --git a/calendar/libedata-cal/e-data-cal.h b/calendar/libedata-cal/e-data-cal.h
index cb97e01..4bb9788 100644
--- a/calendar/libedata-cal/e-data-cal.h
+++ b/calendar/libedata-cal/e-data-cal.h
@@ -124,9 +124,8 @@ struct _EDataCalClass {
 
 GType e_data_cal_get_type (void);
 
-EDataCal *	e_data_cal_new					(ECalBackend *backend, ESource *source);
+EDataCal *	e_data_cal_new					(ECalBackend *backend);
 ECalBackend *	e_data_cal_get_backend				(EDataCal *cal);
-ESource *	e_data_cal_get_source				(EDataCal *cal);
 guint		e_data_cal_register_gdbus_object		(EDataCal *cal, GDBusConnection *connection, const gchar *object_path, GError **error);
 
 void		e_data_cal_respond_open				(EDataCal *cal, guint32 opid, GError *error);
diff --git a/docs/reference/calendar/libedata-cal/libedata-cal-sections.txt b/docs/reference/calendar/libedata-cal/libedata-cal-sections.txt
index 81f0c47..7fea0bc 100644
--- a/docs/reference/calendar/libedata-cal/libedata-cal-sections.txt
+++ b/docs/reference/calendar/libedata-cal/libedata-cal-sections.txt
@@ -11,10 +11,7 @@ CLIENT_BACKEND_PROPERTY_CAPABILITIES
 CAL_BACKEND_PROPERTY_CAL_EMAIL_ADDRESS
 CAL_BACKEND_PROPERTY_ALARM_EMAIL_ADDRESS
 CAL_BACKEND_PROPERTY_DEFAULT_OBJECT
-e_cal_backend_get_source
-e_cal_backend_get_uri
 e_cal_backend_get_kind
-e_cal_backend_is_online
 e_cal_backend_is_opened
 e_cal_backend_is_opening
 e_cal_backend_is_readonly
@@ -29,7 +26,6 @@ e_cal_backend_foreach_view
 e_cal_backend_set_notification_proxy
 e_cal_backend_get_backend_property
 e_cal_backend_set_backend_property
-e_cal_backend_set_online
 e_cal_backend_authenticate_user
 e_cal_backend_open
 e_cal_backend_remove
@@ -117,9 +113,6 @@ e_cal_backend_cache_get_type
 <FILE>e-cal-backend-factory</FILE>
 <TITLE>ECalBackendFactory</TITLE>
 ECalBackendFactory
-e_cal_backend_factory_get_kind
-e_cal_backend_factory_get_protocol
-e_cal_backend_factory_new_backend
 <SUBSECTION Standard>
 E_CAL_BACKEND_FACTORY
 E_IS_CAL_BACKEND_FACTORY
@@ -272,7 +265,6 @@ e_return_data_cal_error_if_fail
 e_return_data_cal_error_val_if_fail
 e_data_cal_new
 e_data_cal_get_backend
-e_data_cal_get_source
 e_data_cal_register_gdbus_object
 e_data_cal_respond_open
 e_data_cal_respond_remove
@@ -331,25 +323,18 @@ ECalBackendSExpClass
 <SECTION>
 <FILE>e-data-cal-factory</FILE>
 <TITLE>EDataCalFactory</TITLE>
-E_DATA_CAL_FACTORY_ERROR
-EDataCalFactoryError
 EDataCalFactory
-e_data_cal_factory_register_backend
-e_data_cal_factory_register_backends
-e_data_cal_factory_get_n_backends
-e_data_cal_factory_dump_active_backends
-e_data_cal_factory_set_backend_online
 <SUBSECTION Standard>
 E_DATA_CAL_FACTORY
 E_IS_DATA_CAL_FACTORY
 E_TYPE_DATA_CAL_FACTORY
 E_DATA_CAL_FACTORY_CLASS
 E_IS_DATA_CAL_FACTORY_CLASS
+E_DATA_CAL_FACTORY_GET_CLASS
 EDataCalFactoryClass
 <SUBSECTION Private>
 EDataCalFactoryPrivate
 e_data_cal_factory_get_type
-e_data_cal_factory_error_quark
 </SECTION>
 
 <SECTION>
diff --git a/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend-factory.sgml b/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend-factory.sgml
index dcef182..092a2a8 100644
--- a/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend-factory.sgml
+++ b/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend-factory.sgml
@@ -26,31 +26,3 @@ Factory for creating backends.
 </para>
 
 
-<!-- ##### FUNCTION e_cal_backend_factory_get_kind ##### -->
-<para>
-
-</para>
-
- factory: 
- Returns: 
-
-
-<!-- ##### FUNCTION e_cal_backend_factory_get_protocol ##### -->
-<para>
-
-</para>
-
- factory: 
- Returns: 
-
-
-<!-- ##### FUNCTION e_cal_backend_factory_new_backend ##### -->
-<para>
-
-</para>
-
- factory: 
- source: 
- Returns: 
-
-
diff --git a/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend.sgml b/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend.sgml
index 2ca7f1e..e6a3cdf 100644
--- a/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend.sgml
+++ b/docs/reference/calendar/libedata-cal/tmpl/e-cal-backend.sgml
@@ -26,13 +26,6 @@ Base class for calendar/tasks backend implementations.
 </para>
 
 
-<!-- ##### SIGNAL ECalBackend::last-client-gone ##### -->
-<para>
-
-</para>
-
- ecalbackend: the object which received the signal.
-
 <!-- ##### ARG ECalBackend:cache-dir ##### -->
 <para>
 
@@ -43,16 +36,6 @@ Base class for calendar/tasks backend implementations.
 
 </para>
 
-<!-- ##### ARG ECalBackend:source ##### -->
-<para>
-
-</para>
-
-<!-- ##### ARG ECalBackend:uri ##### -->
-<para>
-
-</para>
-
 <!-- ##### MACRO CLIENT_BACKEND_PROPERTY_OPENED ##### -->
 <para>
 
@@ -116,24 +99,6 @@ Base class for calendar/tasks backend implementations.
 
 
 
-<!-- ##### FUNCTION e_cal_backend_get_source ##### -->
-<para>
-
-</para>
-
- backend: 
- Returns: 
-
-
-<!-- ##### FUNCTION e_cal_backend_get_uri ##### -->
-<para>
-
-</para>
-
- backend: 
- Returns: 
-
-
 <!-- ##### FUNCTION e_cal_backend_get_kind ##### -->
 <para>
 
@@ -143,15 +108,6 @@ Base class for calendar/tasks backend implementations.
 @Returns: 
 
 
-<!-- ##### FUNCTION e_cal_backend_is_online ##### -->
-<para>
-
-</para>
-
- backend: 
- Returns: 
-
-
 <!-- ##### FUNCTION e_cal_backend_is_opened ##### -->
 <para>
 
@@ -294,15 +250,6 @@ Base class for calendar/tasks backend implementations.
 @prop_value: 
 
 
-<!-- ##### FUNCTION e_cal_backend_set_online ##### -->
-<para>
-
-</para>
-
- backend: 
- is_online: 
-
-
 <!-- ##### FUNCTION e_cal_backend_authenticate_user ##### -->
 <para>
 
diff --git a/docs/reference/calendar/libedata-cal/tmpl/e-data-cal-factory.sgml b/docs/reference/calendar/libedata-cal/tmpl/e-data-cal-factory.sgml
index 64cca46..0cceaf6 100644
--- a/docs/reference/calendar/libedata-cal/tmpl/e-data-cal-factory.sgml
+++ b/docs/reference/calendar/libedata-cal/tmpl/e-data-cal-factory.sgml
@@ -20,20 +20,6 @@ Implementation of the calendar CORBA factory.
 <!-- ##### SECTION Image ##### -->
 
 
-<!-- ##### MACRO E_DATA_CAL_FACTORY_ERROR ##### -->
-<para>
-
-</para>
-
-
-
-<!-- ##### ENUM EDataCalFactoryError ##### -->
-<para>
-
-</para>
-
- E_DATA_CAL_FACTORY_ERROR_GENERIC: 
-
 <!-- ##### STRUCT EDataCalFactory ##### -->
 <para>
 
@@ -42,46 +28,3 @@ Implementation of the calendar CORBA factory.
 @parent: 
 @priv: 
 
-<!-- ##### FUNCTION e_data_cal_factory_register_backend ##### -->
-<para>
-
-</para>
-
- factory: 
- backend_factory: 
-
-
-<!-- ##### FUNCTION e_data_cal_factory_register_backends ##### -->
-<para>
-
-</para>
-
- factory: 
-
-
-<!-- ##### FUNCTION e_data_cal_factory_get_n_backends ##### -->
-<para>
-
-</para>
-
- factory: 
- Returns: 
-
-
-<!-- ##### FUNCTION e_data_cal_factory_dump_active_backends ##### -->
-<para>
-
-</para>
-
- factory: 
-
-
-<!-- ##### FUNCTION e_data_cal_factory_set_backend_online ##### -->
-<para>
-
-</para>
-
- factory: 
- is_online: 
-
-
diff --git a/docs/reference/calendar/libedata-cal/tmpl/e-data-cal.sgml b/docs/reference/calendar/libedata-cal/tmpl/e-data-cal.sgml
index 8ed008a..61a61e0 100644
--- a/docs/reference/calendar/libedata-cal/tmpl/e-data-cal.sgml
+++ b/docs/reference/calendar/libedata-cal/tmpl/e-data-cal.sgml
@@ -33,6 +33,11 @@ Implementation of the calendar CORBA client interface.
 </para>
 
 
+<!-- ##### ARG EDataCal:backend ##### -->
+<para>
+
+</para>
+
 <!-- ##### FUNCTION e_data_cal_create_error ##### -->
 <para>
 
@@ -87,7 +92,6 @@ Implementation of the calendar CORBA client interface.
 </para>
 
 @backend: 
- source: 
 @Returns: 
 
 
@@ -100,15 +104,6 @@ Implementation of the calendar CORBA client interface.
 @Returns: 
 
 
-<!-- ##### FUNCTION e_data_cal_get_source ##### -->
-<para>
-
-</para>
-
- cal: 
- Returns: 
-
-
 <!-- ##### FUNCTION e_data_cal_register_gdbus_object ##### -->
 <para>
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]