Move EActivity and subclasses to e-util.

Planning to write some asynchronous utility functions in e-util that
return EActivity objects.

7 files changed, 1310 insertions, 2 deletions

diff --git a/e-util/Makefile.am b/e-util/Makefile.am
index a869cf1667..2d66a708a4 100644
--- a/e-util/Makefile.am
+++ b/e-util/Makefile.am
@@ -11,6 +11,8 @@ privsolib_LTLIBRARIES = libeutil.la libeconduit.la
 
 eutilinclude_HEADERS = 				\
 	e-account-utils.h			\
+	e-activity.h				\
+	e-alert-activity.h			\
 	e-bconf-map.h				\
 	e-binding.h				\
 	e-categories-config.h			\
@@ -45,6 +47,7 @@ eutilinclude_HEADERS = 				\
 	e-text-event-processor-emacs-like.h	\
 	e-text-event-processor-types.h		\
 	e-text-event-processor.h		\
+	e-timeout-activity.h			\
 	e-util.h				\
 	e-unicode.h				\
 	e-xml-utils.h
@@ -81,6 +84,8 @@ libeutil_la_CPPFLAGS =							\
 libeutil_la_SOURCES =				\
 	$(eutilinclude_HEADERS)			\
 	e-account-utils.c			\
+	e-activity.c				\
+	e-alert-activity.c			\
 	e-bconf-map.c				\
 	e-binding.c				\
 	e-categories-config.c			\
@@ -112,8 +117,9 @@ libeutil_la_SOURCES =				\
 	e-bit-array.c				\
 	e-sorter.c				\
 	e-sorter-array.c			\
-	e-text-event-processor-emacs-like.c     \
-	e-text-event-processor.c                \
+	e-text-event-processor-emacs-like.c	\
+	e-text-event-processor.c		\
+	e-timeout-activity.c			\
 	e-util.c				\
 	e-unicode.c				\
 	e-util-private.h			\
diff --git a/e-util/e-activity.c b/e-util/e-activity.c
new file mode 100644
index 0000000000..9f8faf75cb
--- /dev/null
+++ b/e-util/e-activity.c
@@ -0,0 +1,605 @@
+/*
+ * e-activity.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#include "e-activity.h"
+
+#include <stdarg.h>
+#include <glib/gi18n.h>
+
+#include "e-util/e-util.h"
+
+#define E_ACTIVITY_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_ACTIVITY, EActivityPrivate))
+
+struct _EActivityPrivate {
+	gchar *icon_name;
+	gchar *primary_text;
+	gchar *secondary_text;
+	gdouble percent;
+
+	guint allow_cancel	: 1;
+	guint cancelled		: 1;
+	guint clickable		: 1;
+	guint completed		: 1;
+};
+
+enum {
+	PROP_0,
+	PROP_ALLOW_CANCEL,
+	PROP_CLICKABLE,
+	PROP_ICON_NAME,
+	PROP_PERCENT,
+	PROP_PRIMARY_TEXT,
+	PROP_SECONDARY_TEXT
+};
+
+enum {
+	CANCELLED,
+	CLICKED,
+	COMPLETED,
+	DESCRIBE,
+	LAST_SIGNAL
+};
+
+static gpointer parent_class;
+static gulong signals[LAST_SIGNAL];
+
+static gboolean
+activity_describe_accumulator (GSignalInvocationHint *ihint,
+                               GValue *return_accu,
+                               const GValue *handler_return,
+                               gpointer accu_data)
+{
+	const gchar *string;
+
+	string = g_value_get_string (handler_return);
+	g_value_set_string (return_accu, string);
+
+	return (string == NULL);
+}
+
+static void
+activity_set_property (GObject *object,
+                       guint property_id,
+                       const GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_ALLOW_CANCEL:
+			e_activity_set_allow_cancel (
+				E_ACTIVITY (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_CLICKABLE:
+			e_activity_set_clickable (
+				E_ACTIVITY (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_ICON_NAME:
+			e_activity_set_icon_name (
+				E_ACTIVITY (object),
+				g_value_get_string (value));
+			return;
+
+		case PROP_PERCENT:
+			e_activity_set_percent (
+				E_ACTIVITY (object),
+				g_value_get_double (value));
+			return;
+
+		case PROP_PRIMARY_TEXT:
+			e_activity_set_primary_text (
+				E_ACTIVITY (object),
+				g_value_get_string (value));
+			return;
+
+		case PROP_SECONDARY_TEXT:
+			e_activity_set_secondary_text (
+				E_ACTIVITY (object),
+				g_value_get_string (value));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+activity_get_property (GObject *object,
+                       guint property_id,
+                       GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_ALLOW_CANCEL:
+			g_value_set_boolean (
+				value, e_activity_get_allow_cancel (
+				E_ACTIVITY (object)));
+			return;
+
+		case PROP_CLICKABLE:
+			g_value_set_boolean (
+				value, e_activity_get_clickable (
+				E_ACTIVITY (object)));
+			return;
+
+		case PROP_ICON_NAME:
+			g_value_set_string (
+				value, e_activity_get_icon_name (
+				E_ACTIVITY (object)));
+			return;
+
+		case PROP_PERCENT:
+			g_value_set_double (
+				value, e_activity_get_percent (
+				E_ACTIVITY (object)));
+			return;
+
+		case PROP_PRIMARY_TEXT:
+			g_value_set_string (
+				value, e_activity_get_primary_text (
+				E_ACTIVITY (object)));
+			return;
+
+		case PROP_SECONDARY_TEXT:
+			g_value_set_string (
+				value, e_activity_get_secondary_text (
+				E_ACTIVITY (object)));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+activity_finalize (GObject *object)
+{
+	EActivityPrivate *priv;
+
+	priv = E_ACTIVITY_GET_PRIVATE (object);
+
+	g_free (priv->icon_name);
+	g_free (priv->primary_text);
+	g_free (priv->secondary_text);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+activity_cancelled (EActivity *activity)
+{
+	activity->priv->cancelled = TRUE;
+}
+
+static void
+activity_completed (EActivity *activity)
+{
+	activity->priv->completed = TRUE;
+}
+
+static void
+activity_clicked (EActivity *activity)
+{
+	/* Allow subclasses to safely chain up. */
+}
+
+static gchar *
+activity_describe (EActivity *activity)
+{
+	GString *string;
+	const gchar *text;
+	gboolean cancelled;
+	gboolean completed;
+	gdouble percent;
+
+	string = g_string_sized_new (256);
+	text = e_activity_get_primary_text (activity);
+	cancelled = e_activity_is_cancelled (activity);
+	completed = e_activity_is_completed (activity);
+	percent = e_activity_get_percent (activity);
+
+	if (cancelled) {
+		/* Translators: This is a cancelled activity. */
+		g_string_printf (string, _("%s (cancelled)"), text);
+	} else if (completed) {
+		/* Translators: This is a completed activity. */
+		g_string_printf (string, _("%s (completed)"), text);
+	} else if (percent < 0.0) {
+		/* Translators: This is an activity whose percent
+		 * complete is unknown. */
+		g_string_printf (string, _("%s..."), text);
+	} else {
+		/* Translators: This is an activity whose percent
+		 * complete is known. */
+		g_string_printf (
+			string, _("%s (%d%% complete)"), text,
+			(gint) (percent * 100.0 + 0.5));
+	}
+
+	return g_string_free (string, FALSE);
+}
+
+static void
+activity_class_init (EActivityClass *class)
+{
+	GObjectClass *object_class;
+
+	parent_class = g_type_class_peek_parent (class);
+	g_type_class_add_private (class, sizeof (EActivityPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->set_property = activity_set_property;
+	object_class->get_property = activity_get_property;
+	object_class->finalize = activity_finalize;
+
+	class->cancelled = activity_cancelled;
+	class->completed = activity_completed;
+	class->clicked = activity_clicked;
+	class->describe = activity_describe;
+
+	g_object_class_install_property (
+		object_class,
+		PROP_ALLOW_CANCEL,
+		g_param_spec_boolean (
+			"allow-cancel",
+			NULL,
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_CLICKABLE,
+		g_param_spec_boolean (
+			"clickable",
+			NULL,
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_ICON_NAME,
+		g_param_spec_string (
+			"icon-name",
+			NULL,
+			NULL,
+			NULL,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_PERCENT,
+		g_param_spec_double (
+			"percent",
+			NULL,
+			NULL,
+			-G_MAXDOUBLE,
+			G_MAXDOUBLE,
+			-1.0,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_PRIMARY_TEXT,
+		g_param_spec_string (
+			"primary-text",
+			NULL,
+			NULL,
+			NULL,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_SECONDARY_TEXT,
+		g_param_spec_string (
+			"secondary-text",
+			NULL,
+			NULL,
+			NULL,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	signals[CANCELLED] = g_signal_new (
+		"cancelled",
+		G_OBJECT_CLASS_TYPE (object_class),
+		G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EActivityClass, cancelled),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[CLICKED] = g_signal_new (
+		"clicked",
+		G_OBJECT_CLASS_TYPE (object_class),
+		G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EActivityClass, clicked),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[COMPLETED] = g_signal_new (
+		"completed",
+		G_OBJECT_CLASS_TYPE (object_class),
+		G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EActivityClass, completed),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[DESCRIBE] = g_signal_new (
+		"describe",
+		G_OBJECT_CLASS_TYPE (object_class),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EActivityClass, describe),
+		activity_describe_accumulator, NULL,
+		e_marshal_STRING__VOID,
+		G_TYPE_STRING, 0);
+}
+
+static void
+activity_init (EActivity *activity)
+{
+	activity->priv = E_ACTIVITY_GET_PRIVATE (activity);
+}
+
+GType
+e_activity_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0)) {
+		static const GTypeInfo type_info = {
+			sizeof (EActivityClass),
+			(GBaseInitFunc) NULL,
+			(GBaseFinalizeFunc) NULL,
+			(GClassInitFunc) activity_class_init,
+			(GClassFinalizeFunc) NULL,
+			NULL,  /* class_data */
+			sizeof (EActivity),
+			0,     /* n_preallocs */
+			(GInstanceInitFunc) activity_init,
+			NULL   /* value_table */
+		};
+
+		type = g_type_register_static (
+			G_TYPE_OBJECT, "EActivity", &type_info, 0);
+	}
+
+	return type;
+}
+
+EActivity *
+e_activity_new (const gchar *primary_text)
+{
+	return g_object_new (
+		E_TYPE_ACTIVITY,
+		"primary-text", primary_text, NULL);
+}
+
+EActivity *
+e_activity_newv (const gchar *format, ...)
+{
+	EActivity *activity;
+	gchar *primary_text;
+	va_list args;
+
+	va_start (args, format);
+	primary_text = g_strdup_vprintf (format, args);
+	activity = e_activity_new (primary_text);
+	g_free (primary_text);
+	va_end (args);
+
+	return activity;
+}
+
+void
+e_activity_cancel (EActivity *activity)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	if (!activity->priv->allow_cancel)
+		return;
+
+	if (activity->priv->cancelled)
+		return;
+
+	if (activity->priv->completed)
+		return;
+
+	g_signal_emit (activity, signals[CANCELLED], 0);
+}
+
+void
+e_activity_complete (EActivity *activity)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	if (activity->priv->cancelled)
+		return;
+
+	if (activity->priv->completed)
+		return;
+
+	g_signal_emit (activity, signals[COMPLETED], 0);
+}
+
+void
+e_activity_clicked (EActivity *activity)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	g_signal_emit (activity, signals[CLICKED], 0);
+}
+
+gchar *
+e_activity_describe (EActivity *activity)
+{
+	EActivityClass *class;
+
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), NULL);
+
+	class = E_ACTIVITY_GET_CLASS (activity);
+	g_return_val_if_fail (class->describe != NULL, NULL);
+
+	return class->describe (activity);
+}
+
+gboolean
+e_activity_is_cancelled (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), FALSE);
+
+	return activity->priv->cancelled;
+}
+
+gboolean
+e_activity_is_completed (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), FALSE);
+
+	return activity->priv->completed;
+}
+
+gboolean
+e_activity_get_allow_cancel (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), FALSE);
+
+	return activity->priv->allow_cancel;
+}
+
+void
+e_activity_set_allow_cancel (EActivity *activity,
+                            gboolean allow_cancel)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	activity->priv->allow_cancel = allow_cancel;
+
+	g_object_notify (G_OBJECT (activity), "allow-cancel");
+}
+
+gboolean
+e_activity_get_clickable (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), FALSE);
+
+	return activity->priv->clickable;
+}
+
+void
+e_activity_set_clickable (EActivity *activity,
+                          gboolean clickable)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	activity->priv->clickable = clickable;
+
+	g_object_notify (G_OBJECT (activity), "clickable");
+}
+
+const gchar *
+e_activity_get_icon_name (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), NULL);
+
+	return activity->priv->icon_name;
+}
+
+void
+e_activity_set_icon_name (EActivity *activity,
+                          const gchar *icon_name)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	g_free (activity->priv->icon_name);
+	activity->priv->icon_name = g_strdup (icon_name);
+
+	g_object_notify (G_OBJECT (activity), "icon-name");
+}
+
+gdouble
+e_activity_get_percent (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), -1.0);
+
+	return activity->priv->percent;
+}
+
+void
+e_activity_set_percent (EActivity *activity,
+                        gdouble percent)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	activity->priv->percent = percent;
+
+	g_object_notify (G_OBJECT (activity), "percent");
+}
+
+const gchar *
+e_activity_get_primary_text (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), NULL);
+
+	return activity->priv->primary_text;
+}
+
+void
+e_activity_set_primary_text (EActivity *activity,
+                             const gchar *primary_text)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	g_free (activity->priv->primary_text);
+	activity->priv->primary_text = g_strdup (primary_text);
+
+	g_object_notify (G_OBJECT (activity), "primary-text");
+}
+
+const gchar *
+e_activity_get_secondary_text (EActivity *activity)
+{
+	g_return_val_if_fail (E_IS_ACTIVITY (activity), NULL);
+
+	return activity->priv->secondary_text;
+}
+
+void
+e_activity_set_secondary_text (EActivity *activity,
+                               const gchar *secondary_text)
+{
+	g_return_if_fail (E_IS_ACTIVITY (activity));
+
+	g_free (activity->priv->secondary_text);
+	activity->priv->secondary_text = g_strdup (secondary_text);
+
+	g_object_notify (G_OBJECT (activity), "secondary-text");
+}
diff --git a/e-util/e-activity.h b/e-util/e-activity.h
new file mode 100644
index 0000000000..b396e3a630
--- /dev/null
+++ b/e-util/e-activity.h
@@ -0,0 +1,98 @@
+/*
+ * e-activity.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#ifndef E_ACTIVITY_H
+#define E_ACTIVITY_H
+
+#include <gtk/gtk.h>
+
+/* Standard GObject macros */
+#define E_TYPE_ACTIVITY \
+	(e_activity_get_type ())
+#define E_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_ACTIVITY, EActivity))
+#define E_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_ACTIVITY, EActivityClass))
+#define E_IS_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_ACTIVITY))
+#define E_IS_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_ACTIVITY))
+#define E_ACTIVITY_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_ACTIVITY, EActivityClass))
+
+G_BEGIN_DECLS
+
+typedef struct _EActivity EActivity;
+typedef struct _EActivityClass EActivityClass;
+typedef struct _EActivityPrivate EActivityPrivate;
+
+struct _EActivity {
+	GObject parent;
+	EActivityPrivate *priv;
+};
+
+struct _EActivityClass {
+	GObjectClass parent_class;
+
+	/* Signals */
+	void		(*cancelled)		(EActivity *activity);
+	void		(*completed)		(EActivity *activity);
+	void		(*clicked)		(EActivity *activity);
+	gchar *		(*describe)		(EActivity *activity);
+};
+
+GType		e_activity_get_type		(void);
+EActivity *	e_activity_new			(const gchar *primary_text);
+EActivity *	e_activity_newv			(const gchar *format,
+						 ...) G_GNUC_PRINTF (1, 2);
+void		e_activity_cancel		(EActivity *activity);
+void		e_activity_complete		(EActivity *activity);
+void		e_activity_clicked		(EActivity *activity);
+gchar *		e_activity_describe		(EActivity *activity);
+gboolean	e_activity_is_cancelled		(EActivity *activity);
+gboolean	e_activity_is_completed		(EActivity *activity);
+gboolean	e_activity_get_allow_cancel	(EActivity *activity);
+void		e_activity_set_allow_cancel	(EActivity *activity,
+						 gboolean allow_cancel);
+gboolean	e_activity_get_clickable	(EActivity *activity);
+void		e_activity_set_clickable	(EActivity *activity,
+						 gboolean clickable);
+const gchar *	e_activity_get_icon_name	(EActivity *activity);
+void		e_activity_set_icon_name	(EActivity *activity,
+						 const gchar *icon_name);
+gdouble		e_activity_get_percent		(EActivity *activity);
+void		e_activity_set_percent		(EActivity *activity,
+						 gdouble percent);
+const gchar *	e_activity_get_primary_text	(EActivity *activity);
+void		e_activity_set_primary_text	(EActivity *activity,
+						 const gchar *primary_text);
+const gchar *	e_activity_get_secondary_text	(EActivity *activity);
+void		e_activity_set_secondary_text	(EActivity *activity,
+						 const gchar *secondary_text);
+
+G_END_DECLS
+
+#endif /* E_ACTIVITY_H */
diff --git a/e-util/e-alert-activity.c b/e-util/e-alert-activity.c
new file mode 100644
index 0000000000..1e8f915213
--- /dev/null
+++ b/e-util/e-alert-activity.c
@@ -0,0 +1,258 @@
+/*
+ * e-alert-activity.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#include "e-alert-activity.h"
+
+#define E_ALERT_ACTIVITY_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_ALERT_ACTIVITY, EAlertActivityPrivate))
+
+struct _EAlertActivityPrivate {
+	GtkWidget *message_dialog;
+};
+
+enum {
+	PROP_0,
+	PROP_MESSAGE_DIALOG
+};
+
+static gpointer parent_class;
+
+static void
+alert_activity_set_message_dialog (EAlertActivity *alert_activity,
+                                   GtkWidget *message_dialog)
+{
+	g_return_if_fail (alert_activity->priv->message_dialog == NULL);
+
+	alert_activity->priv->message_dialog = g_object_ref (message_dialog);
+}
+
+static void
+alert_activity_set_property (GObject *object,
+                             guint property_id,
+                             const GValue *value,
+                             GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_MESSAGE_DIALOG:
+			alert_activity_set_message_dialog (
+				E_ALERT_ACTIVITY (object),
+				g_value_get_object (value));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+alert_activity_get_property (GObject *object,
+                             guint property_id,
+                             GValue *value,
+                             GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_MESSAGE_DIALOG:
+			g_value_set_object (
+				value, e_alert_activity_get_message_dialog (
+				E_ALERT_ACTIVITY (object)));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+alert_activity_dispose (GObject *object)
+{
+	EAlertActivityPrivate *priv;
+
+	priv = E_ALERT_ACTIVITY_GET_PRIVATE (object);
+
+	if (priv->message_dialog != NULL) {
+		g_object_unref (priv->message_dialog);
+		priv->message_dialog = NULL;
+	}
+
+	/* Chain up to parent's dispose() method. */
+	G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+alert_activity_constructed (GObject *object)
+{
+	EActivity *activity;
+	EAlertActivity *alert_activity;
+	GtkWidget *message_dialog;
+	const gchar *primary_text;
+	const gchar *secondary_text;
+
+	alert_activity = E_ALERT_ACTIVITY (object);
+	message_dialog = e_alert_activity_get_message_dialog (alert_activity);
+
+	object = G_OBJECT (message_dialog);
+	primary_text = g_object_get_data (object, "primary");
+	secondary_text = g_object_get_data (object, "secondary");
+
+	activity = E_ACTIVITY (alert_activity);
+	e_activity_set_primary_text (activity, primary_text);
+	e_activity_set_secondary_text (activity, secondary_text);
+
+	/* This is a constructor property, so can't do it in init().
+	 * XXX What we really want to do is override the property's
+	 *     default value, but GObject does not support that. */
+	e_activity_set_clickable (E_ACTIVITY (alert_activity), TRUE);
+}
+
+static void
+alert_activity_clicked (EActivity *activity)
+{
+	EAlertActivity *alert_activity;
+	GtkWidget *message_dialog;
+
+	e_activity_complete (activity);
+
+	alert_activity = E_ALERT_ACTIVITY (activity);
+	message_dialog = e_alert_activity_get_message_dialog (alert_activity);
+	gtk_dialog_run (GTK_DIALOG (message_dialog));
+	gtk_widget_hide (message_dialog);
+
+	/* Chain up to parent's clicked() method. */
+	E_ACTIVITY_CLASS (parent_class)->clicked (activity);
+}
+
+static void
+alert_activity_timeout (ETimeoutActivity *activity)
+{
+	e_activity_complete (E_ACTIVITY (activity));
+
+	/* Chain up to parent's timeout() method. */
+	E_TIMEOUT_ACTIVITY_CLASS (parent_class)->timeout (activity);
+}
+
+static void
+alert_activity_class_init (EAlertActivityClass *class)
+{
+	GObjectClass *object_class;
+	EActivityClass *activity_class;
+	ETimeoutActivityClass *timeout_activity_class;
+
+	parent_class = g_type_class_peek_parent (class);
+	g_type_class_add_private (class, sizeof (EAlertActivityPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->set_property = alert_activity_set_property;
+	object_class->get_property = alert_activity_get_property;
+	object_class->dispose = alert_activity_dispose;
+	object_class->constructed = alert_activity_constructed;
+
+	activity_class = E_ACTIVITY_CLASS (class);
+	activity_class->clicked = alert_activity_clicked;
+
+	timeout_activity_class = E_TIMEOUT_ACTIVITY_CLASS (class);
+	timeout_activity_class->timeout = alert_activity_timeout;
+
+	g_object_class_install_property (
+		object_class,
+		PROP_MESSAGE_DIALOG,
+		g_param_spec_object (
+			"message-dialog",
+			NULL,
+			NULL,
+			GTK_TYPE_DIALOG,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT_ONLY));
+}
+
+static void
+alert_activity_init (EAlertActivity *alert_activity)
+{
+	alert_activity->priv = E_ALERT_ACTIVITY_GET_PRIVATE (alert_activity);
+
+	e_timeout_activity_set_timeout (E_TIMEOUT_ACTIVITY (alert_activity), 60);
+}
+
+GType
+e_alert_activity_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0)) {
+		static const GTypeInfo type_info = {
+			sizeof (EAlertActivityClass),
+			(GBaseInitFunc) NULL,
+			(GBaseFinalizeFunc) NULL,
+			(GClassInitFunc) alert_activity_class_init,
+			(GClassFinalizeFunc) NULL,
+			NULL,  /* class_data */
+			sizeof (EAlertActivity),
+			0,     /* n_preallocs */
+			(GInstanceInitFunc) alert_activity_init,
+			NULL   /* value_table */
+		};
+
+		type = g_type_register_static (
+			E_TYPE_TIMEOUT_ACTIVITY, "EAlertActivity",
+			&type_info, 0);
+	}
+
+	return type;
+}
+
+EActivity *
+e_alert_activity_new_info (GtkWidget *message_dialog)
+{
+	g_return_val_if_fail (GTK_IS_DIALOG (message_dialog), NULL);
+
+	return g_object_new (
+		E_TYPE_ALERT_ACTIVITY,
+		"icon-name", "dialog-information",
+		"message-dialog", message_dialog, NULL);
+}
+
+EActivity *
+e_alert_activity_new_error (GtkWidget *message_dialog)
+{
+	g_return_val_if_fail (GTK_IS_DIALOG (message_dialog), NULL);
+
+	return g_object_new (
+		E_TYPE_ALERT_ACTIVITY,
+		"icon-name", "dialog-error",
+		"message-dialog", message_dialog, NULL);
+}
+
+EActivity *
+e_alert_activity_new_warning (GtkWidget *message_dialog)
+{
+	g_return_val_if_fail (GTK_IS_DIALOG (message_dialog), NULL);
+
+	return g_object_new (
+		E_TYPE_ALERT_ACTIVITY,
+		"icon-name", "dialog-warning",
+		"message-dialog", message_dialog, NULL);
+}
+
+GtkWidget *
+e_alert_activity_get_message_dialog (EAlertActivity *alert_activity)
+{
+	g_return_val_if_fail (E_IS_ALERT_ACTIVITY (alert_activity), NULL);
+
+	return alert_activity->priv->message_dialog;
+}
diff --git a/e-util/e-alert-activity.h b/e-util/e-alert-activity.h
new file mode 100644
index 0000000000..b19d7600e3
--- /dev/null
+++ b/e-util/e-alert-activity.h
@@ -0,0 +1,70 @@
+/*
+ * e-alert-activity.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#ifndef E_ALERT_ACTIVITY_H
+#define E_ALERT_ACTIVITY_H
+
+#include <e-util/e-timeout-activity.h>
+
+/* Standard GObject macros */
+#define E_TYPE_ALERT_ACTIVITY \
+	(e_alert_activity_get_type ())
+#define E_ALERT_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_ALERT_ACTIVITY, EAlertActivity))
+#define E_ALERT_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_ALERT_ACTIVITY, EAlertActivityClass))
+#define E_IS_ALERT_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_ALERT_ACTIVITY))
+#define E_IS_ALERT_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_ALERT_ACTIVITY))
+#define E_ALERT_ACTIVITY_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_ALERT_ACTIVITY, EAlertActivityClass))
+
+G_BEGIN_DECLS
+
+typedef struct _EAlertActivity EAlertActivity;
+typedef struct _EAlertActivityClass EAlertActivityClass;
+typedef struct _EAlertActivityPrivate EAlertActivityPrivate;
+
+struct _EAlertActivity {
+	ETimeoutActivity parent;
+	EAlertActivityPrivate *priv;
+};
+
+struct _EAlertActivityClass {
+	ETimeoutActivityClass parent_class;
+};
+
+GType		e_alert_activity_get_type	(void);
+EActivity *	e_alert_activity_new_info	(GtkWidget *message_dialog);
+EActivity *	e_alert_activity_new_error	(GtkWidget *message_dialog);
+EActivity *	e_alert_activity_new_warning	(GtkWidget *message_dialog);
+GtkWidget *	e_alert_activity_get_message_dialog
+						(EAlertActivity *alert_activity);
+
+G_END_DECLS
+
+#endif /* E_ALERT_ACTIVITY_H */
diff --git a/e-util/e-timeout-activity.c b/e-util/e-timeout-activity.c
new file mode 100644
index 0000000000..aa57960fe0
--- /dev/null
+++ b/e-util/e-timeout-activity.c
@@ -0,0 +1,198 @@
+/*
+ * e-timeout-activity.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#include "e-timeout-activity.h"
+
+#include <stdarg.h>
+
+#define E_TIMEOUT_ACTIVITY_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_TIMEOUT_ACTIVITY, ETimeoutActivityPrivate))
+
+struct _ETimeoutActivityPrivate {
+	guint timeout_id;
+};
+
+enum {
+	TIMEOUT,
+	LAST_SIGNAL
+};
+
+static gpointer parent_class;
+static gulong signals[LAST_SIGNAL];
+
+static gboolean
+timeout_activity_cb (ETimeoutActivity *timeout_activity)
+{
+	g_signal_emit (timeout_activity, signals[TIMEOUT], 0);
+
+	return FALSE;
+}
+
+static void
+timeout_activity_finalize (GObject *object)
+{
+	ETimeoutActivityPrivate *priv;
+
+	priv = E_TIMEOUT_ACTIVITY_GET_PRIVATE (object);
+
+	if (priv->timeout_id > 0)
+		g_source_remove (priv->timeout_id);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+timeout_activity_cancelled (EActivity *activity)
+{
+	ETimeoutActivityPrivate *priv;
+
+	priv = E_TIMEOUT_ACTIVITY_GET_PRIVATE (activity);
+
+	if (priv->timeout_id > 0) {
+		g_source_remove (priv->timeout_id);
+		priv->timeout_id = 0;
+	}
+
+	/* Chain up to parent's cancelled() method. */
+	E_ACTIVITY_CLASS (parent_class)->cancelled (activity);
+}
+
+static void
+timeout_activity_completed (EActivity *activity)
+{
+	ETimeoutActivityPrivate *priv;
+
+	priv = E_TIMEOUT_ACTIVITY_GET_PRIVATE (activity);
+
+	if (priv->timeout_id > 0) {
+		g_source_remove (priv->timeout_id);
+		priv->timeout_id = 0;
+	}
+
+	/* Chain up to parent's completed() method. */
+	E_ACTIVITY_CLASS (parent_class)->completed (activity);
+}
+
+static void
+timeout_activity_timeout (ETimeoutActivity *timeout_activity)
+{
+	/* Allow subclasses to safely chain up. */
+}
+
+static void
+timeout_activity_class_init (ETimeoutActivityClass *class)
+{
+	GObjectClass *object_class;
+	EActivityClass *activity_class;
+
+	parent_class = g_type_class_peek_parent (class);
+	g_type_class_add_private (class, sizeof (ETimeoutActivityPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->finalize = timeout_activity_finalize;
+
+	activity_class = E_ACTIVITY_CLASS (class);
+	activity_class->cancelled = timeout_activity_cancelled;
+	activity_class->completed = timeout_activity_completed;
+
+	class->timeout = timeout_activity_timeout;
+
+	signals[TIMEOUT] = g_signal_new (
+		"timeout",
+		G_OBJECT_CLASS_TYPE (object_class),
+		G_SIGNAL_RUN_FIRST,
+		G_STRUCT_OFFSET (ETimeoutActivityClass, timeout),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+}
+
+static void
+timeout_activity_init (ETimeoutActivity *timeout_activity)
+{
+	timeout_activity->priv =
+		E_TIMEOUT_ACTIVITY_GET_PRIVATE (timeout_activity);
+}
+
+GType
+e_timeout_activity_get_type (void)
+{
+	static GType type = 0;
+
+	if (G_UNLIKELY (type == 0)) {
+		static const GTypeInfo type_info = {
+			sizeof (ETimeoutActivityClass),
+			(GBaseInitFunc) NULL,
+			(GBaseFinalizeFunc) NULL,
+			(GClassInitFunc) timeout_activity_class_init,
+			(GClassFinalizeFunc) NULL,
+			NULL,  /* class_data */
+			sizeof (ETimeoutActivity),
+			0,     /* n_preallocs */
+			(GInstanceInitFunc) timeout_activity_init,
+			NULL   /* value_table */
+		};
+
+		type = g_type_register_static (
+			E_TYPE_ACTIVITY, "ETimeoutActivity", &type_info, 0);
+	}
+
+	return type;
+}
+
+EActivity *
+e_timeout_activity_new (const gchar *primary_text)
+{
+	return g_object_new (
+		E_TYPE_TIMEOUT_ACTIVITY,
+		"primary-text", primary_text, NULL);
+}
+
+EActivity *
+e_timeout_activity_newv (const gchar *format, ...)
+{
+	EActivity *activity;
+	gchar *primary_text;
+	va_list args;
+
+	va_start (args, format);
+	primary_text = g_strdup_vprintf (format, args);
+	activity = e_timeout_activity_new (primary_text);
+	g_free (primary_text);
+	va_end (args);
+
+	return activity;
+}
+
+void
+e_timeout_activity_set_timeout (ETimeoutActivity *timeout_activity,
+                                guint seconds)
+{
+	g_return_if_fail (E_IS_TIMEOUT_ACTIVITY (timeout_activity));
+
+	if (timeout_activity->priv->timeout_id > 0)
+		e_activity_cancel (E_ACTIVITY (timeout_activity));
+
+	timeout_activity->priv->timeout_id = g_timeout_add_seconds (
+		seconds, (GSourceFunc) timeout_activity_cb, timeout_activity);
+}
diff --git a/e-util/e-timeout-activity.h b/e-util/e-timeout-activity.h
new file mode 100644
index 0000000000..7545568e13
--- /dev/null
+++ b/e-util/e-timeout-activity.h
@@ -0,0 +1,73 @@
+/*
+ * e-timeout-activity.h
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#ifndef E_TIMEOUT_ACTIVITY_H
+#define E_TIMEOUT_ACTIVITY_H
+
+#include <e-util/e-activity.h>
+
+/* Standard GObject macros */
+#define E_TYPE_TIMEOUT_ACTIVITY \
+	(e_timeout_activity_get_type ())
+#define E_TIMEOUT_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_TIMEOUT_ACTIVITY, ETimeoutActivity))
+#define E_TIMEOUT_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_TIMEOUT_ACTIVITY, ETimeoutActivityClass))
+#define E_IS_TIMEOUT_ACTIVITY(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_TIMEOUT_ACTIVITY))
+#define E_IS_TIMEOUT_ACTIVITY_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_TIMEOUT_ACTIVITY))
+#define E_TIMEOUT_ACTIVITY_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_TIMEOUT_ACTIVITY, ETimeoutActivityClass))
+
+G_BEGIN_DECLS
+
+typedef struct _ETimeoutActivity ETimeoutActivity;
+typedef struct _ETimeoutActivityClass ETimeoutActivityClass;
+typedef struct _ETimeoutActivityPrivate ETimeoutActivityPrivate;
+
+struct _ETimeoutActivity {
+	EActivity parent;
+	ETimeoutActivityPrivate *priv;
+};
+
+struct _ETimeoutActivityClass {
+	EActivityClass parent_class;
+
+	/* Signals */
+	void		(*timeout)	(ETimeoutActivity *timeout_activity);
+};
+
+GType		e_timeout_activity_get_type	(void);
+EActivity *	e_timeout_activity_new		(const gchar *primary_text);
+EActivity *	e_timeout_activity_newv		(const gchar *format,
+						 ...) G_GNUC_PRINTF (1, 2);
+void		e_timeout_activity_set_timeout	(ETimeoutActivity *timeout_activity,
+						 guint seconds);
+
+G_END_DECLS
+
+#endif /* E_TIMEOUT_ACTIVITY_H */