[evolution/webkit: 10/171] Create EWebViewGtkHTML class to be used by the Composer until ported

[Dan VrÃtil <dvratil src gnome org>]

commit 95341498862c2c9fe47c4351603d7fa50ef59d24
Author: Dan VrÃtil <dvratil redhat com>
Date:   Wed Jul 27 18:25:34 2011 +0200

    Create EWebViewGtkHTML class to be used by the Composer until ported
    
    Until the Composer is ported to WebKit, it requires a GtkHTML-based
    EWebView to exists. The EWebViewGtkHTML class is identical to
    master's EWebView, only everything is renamed.

 composer/e-composer-actions.c     |    2 +-
 composer/e-composer-activity.c    |   10 +-
 composer/e-composer-private.c     |    2 +-
 composer/e-composer-private.h     |    2 +-
 composer/e-msg-composer.c         |   22 +-
 composer/e-msg-composer.h         |    5 +-
 widgets/misc/Makefile.am          |    2 +
 widgets/misc/e-web-view-gtkhtml.c | 2300 +++++++++++++++++++++++++++++++++++++
 widgets/misc/e-web-view-gtkhtml.h |  173 +++
 9 files changed, 2497 insertions(+), 21 deletions(-)
---
diff --git a/composer/e-composer-actions.c b/composer/e-composer-actions.c
index cd50f7a..7d57ddb 100644
--- a/composer/e-composer-actions.c
+++ b/composer/e-composer-actions.c
@@ -462,7 +462,7 @@ e_composer_actions_init (EMsgComposer *composer)
 	GtkActionGroup *action_group;
 	GtkUIManager *ui_manager;
 	GtkhtmlEditor *editor;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	gboolean visible;
 
 	g_return_if_fail (E_IS_MSG_COMPOSER (composer));
diff --git a/composer/e-composer-activity.c b/composer/e-composer-activity.c
index 603a271..a74e5cd 100644
--- a/composer/e-composer-activity.c
+++ b/composer/e-composer-activity.c
@@ -46,14 +46,14 @@ composer_activity_lock_interface (EComposerActivity *activity)
 {
 	GtkActionGroup *action_group;
 	EMsgComposer *composer;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	gboolean editable;
 
 	composer = e_composer_activity_get_composer (activity);
 
 	web_view = e_msg_composer_get_web_view (composer);
-	editable = e_web_view_get_editable (web_view);
-	e_web_view_set_editable (web_view, FALSE);
+	editable = e_web_view_gtkhtml_get_editable (web_view);
+	e_web_view_gtkhtml_set_editable (web_view, FALSE);
 	activity->priv->saved_editable = editable;
 
 	action_group = composer->priv->async_actions;
@@ -65,14 +65,14 @@ composer_activity_unlock_interface (EComposerActivity *activity)
 {
 	GtkActionGroup *action_group;
 	EMsgComposer *composer;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	gboolean editable;
 
 	composer = e_composer_activity_get_composer (activity);
 
 	editable = activity->priv->saved_editable;
 	web_view = e_msg_composer_get_web_view (composer);
-	e_web_view_set_editable (web_view, editable);
+	e_web_view_gtkhtml_set_editable (web_view, editable);
 
 	action_group = composer->priv->async_actions;
 	gtk_action_group_set_sensitive (action_group, TRUE);
diff --git a/composer/e-composer-private.c b/composer/e-composer-private.c
index 3441c6b..477aae4 100644
--- a/composer/e-composer-private.c
+++ b/composer/e-composer-private.c
@@ -129,7 +129,7 @@ e_composer_private_constructed (EMsgComposer *composer)
 	EFocusTracker *focus_tracker;
 	EShell *shell;
 	EShellSettings *shell_settings;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	GtkhtmlEditor *editor;
 	GtkUIManager *ui_manager;
 	GtkAction *action;
diff --git a/composer/e-composer-private.h b/composer/e-composer-private.h
index 4282d57..1db0465 100644
--- a/composer/e-composer-private.h
+++ b/composer/e-composer-private.h
@@ -51,7 +51,7 @@
 #include "widgets/misc/e-picture-gallery.h"
 #include "widgets/misc/e-preferences-window.h"
 #include "widgets/misc/e-signature-combo-box.h"
-#include "widgets/misc/e-web-view.h"
+#include "widgets/misc/e-web-view-gtkhtml.h"
 #include "shell/e-shell.h"
 
 #ifdef HAVE_XFREE
diff --git a/composer/e-msg-composer.c b/composer/e-msg-composer.c
index 9f32d8c..3a44fa2 100644
--- a/composer/e-msg-composer.c
+++ b/composer/e-msg-composer.c
@@ -1691,7 +1691,7 @@ msg_composer_paste_clipboard_targets_cb (GtkClipboard *clipboard,
 }
 
 static void
-msg_composer_paste_clipboard_cb (EWebView *web_view,
+msg_composer_paste_clipboard_cb (EWebViewGtkHTML *web_view,
                                  EMsgComposer *composer)
 {
 	GtkClipboard *clipboard;
@@ -1721,7 +1721,7 @@ msg_composer_realize_gtkhtml_cb (GtkWidget *widget,
 
 	/* When redirecting a message, the message body is not
 	 * editable and therefore cannot be a drag destination. */
-	if (!e_web_view_get_editable (E_WEB_VIEW (widget)))
+	if (!e_web_view_gtkhtml_get_editable (E_WEB_VIEW_GTKHTML (widget)))
 		return;
 
 	view = e_msg_composer_get_attachment_view (composer);
@@ -1969,7 +1969,7 @@ msg_composer_constructed (GObject *object)
 	EAttachmentView *view;
 	EAttachmentStore *store;
 	EComposerHeaderTable *table;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	GtkUIManager *ui_manager;
 	GtkToggleAction *action;
 	const gchar *id;
@@ -2179,7 +2179,7 @@ msg_composer_key_press_event (GtkWidget *widget,
 	EMsgComposer *composer = E_MSG_COMPOSER (widget);
 	GtkWidget *input_widget;
 	GtkhtmlEditor *editor;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 
 	editor = GTKHTML_EDITOR (widget);
 	composer = E_MSG_COMPOSER (widget);
@@ -2558,7 +2558,7 @@ e_msg_composer_new (EShell *shell)
 
 	return g_object_new (
 		E_TYPE_MSG_COMPOSER,
-		"html", e_web_view_new (), "shell", shell, NULL);
+		"html", e_web_view_gtkhtml_new (), "shell", shell, NULL);
 }
 
 EFocusTracker *
@@ -3389,7 +3389,7 @@ e_msg_composer_new_redirect (EShell *shell,
 {
 	EMsgComposer *composer;
 	EComposerHeaderTable *table;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	const gchar *subject;
 
 	g_return_val_if_fail (E_IS_SHELL (shell), NULL);
@@ -3408,7 +3408,7 @@ e_msg_composer_new_redirect (EShell *shell,
 	e_composer_header_table_set_subject (table, subject);
 
 	web_view = e_msg_composer_get_web_view (composer);
-	e_web_view_set_editable (web_view, FALSE);
+	e_web_view_gtkhtml_set_editable (web_view, FALSE);
 
 	return composer;
 }
@@ -3464,7 +3464,7 @@ e_msg_composer_get_shell (EMsgComposer *composer)
  *
  * Returns: the #EWebView
  **/
-EWebView *
+EWebViewGtkHTML *
 e_msg_composer_get_web_view (EMsgComposer *composer)
 {
 	GtkHTML *html;
@@ -3477,7 +3477,7 @@ e_msg_composer_get_web_view (EMsgComposer *composer)
 	editor = GTKHTML_EDITOR (composer);
 	html = gtkhtml_editor_get_html (editor);
 
-	return E_WEB_VIEW (html);
+	return E_WEB_VIEW_GTKHTML (html);
 }
 
 static void
@@ -4152,7 +4152,7 @@ e_msg_composer_set_body (EMsgComposer *composer,
 {
 	EMsgComposerPrivate *p = composer->priv;
 	EComposerHeaderTable *table;
-	EWebView *web_view;
+	EWebViewGtkHTML *web_view;
 	gchar *buff;
 
 	g_return_if_fail (E_IS_MSG_COMPOSER (composer));
@@ -4168,7 +4168,7 @@ e_msg_composer_set_body (EMsgComposer *composer,
 	gtkhtml_editor_set_html_mode (GTKHTML_EDITOR (composer), FALSE);
 
 	web_view = e_msg_composer_get_web_view (composer);
-	e_web_view_set_editable (web_view, FALSE);
+	e_web_view_gtkhtml_set_editable (web_view, FALSE);
 
 	g_free (p->mime_body);
 	p->mime_body = g_strdup (body);
diff --git a/composer/e-msg-composer.h b/composer/e-msg-composer.h
index 258d260..aa63b0e 100644
--- a/composer/e-msg-composer.h
+++ b/composer/e-msg-composer.h
@@ -30,7 +30,7 @@
 #include <gtkhtml-editor.h>
 #include <misc/e-attachment-view.h>
 #include <misc/e-focus-tracker.h>
-#include <misc/e-web-view.h>
+#include <misc/e-web-view-gtkhtml.h>
 #include <shell/e-shell.h>
 
 #include <composer/e-composer-header-table.h>
@@ -100,7 +100,8 @@ EFocusTracker *	e_msg_composer_get_focus_tracker
 						(EMsgComposer *composer);
 CamelSession *	e_msg_composer_get_session	(EMsgComposer *composer);
 EShell *	e_msg_composer_get_shell	(EMsgComposer *composer);
-EWebView *	e_msg_composer_get_web_view	(EMsgComposer *composer);
+EWebViewGtkHTML *
+		e_msg_composer_get_web_view	(EMsgComposer *composer);
 
 void		e_msg_composer_send		(EMsgComposer *composer);
 void		e_msg_composer_save_to_drafts	(EMsgComposer *composer);
diff --git a/widgets/misc/Makefile.am b/widgets/misc/Makefile.am
index c7580fb..160845f 100644
--- a/widgets/misc/Makefile.am
+++ b/widgets/misc/Makefile.am
@@ -63,6 +63,7 @@ widgetsinclude_HEADERS =			\
 	e-signature-tree-view.h			\
 	e-url-entry.h				\
 	e-web-view.h				\
+	e-web-view-gtkhtml.h			\
 	e-web-view-preview.h			\
 	ea-calendar-cell.h			\
 	ea-calendar-item.h			\
@@ -144,6 +145,7 @@ libemiscwidgets_la_SOURCES =			\
 	e-signature-tree-view.c			\
 	e-url-entry.c				\
 	e-web-view.c				\
+	e-web-view-gtkhtml.c			\
 	e-web-view-preview.c			\
 	ea-calendar-cell.c			\
 	ea-calendar-item.c			\
diff --git a/widgets/misc/e-web-view-gtkhtml.c b/widgets/misc/e-web-view-gtkhtml.c
new file mode 100644
index 0000000..c7a2dc3
--- /dev/null
+++ b/widgets/misc/e-web-view-gtkhtml.c
@@ -0,0 +1,2300 @@
+/*
+ * e-web-view-gtkhtml.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/>
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "e-web-view-gtkhtml.h"
+
+#include <string.h>
+#include <glib/gi18n-lib.h>
+
+#include <camel/camel.h>
+
+#include <e-util/e-util.h>
+#include <e-util/e-alert-dialog.h>
+#include <e-util/e-alert-sink.h>
+#include <e-util/e-extensible.h>
+#include <e-util/e-plugin-ui.h>
+
+#include "e-popup-action.h"
+#include "e-selectable.h"
+
+#define E_WEB_VIEW_GTKHTML_GET_PRIVATE(obj) \
+	(G_TYPE_INSTANCE_GET_PRIVATE \
+	((obj), E_TYPE_WEB_VIEW_GTKHTML, EWebViewGtkHTMLPrivate))
+
+typedef struct _EWebViewGtkHTMLRequest EWebViewGtkHTMLRequest;
+
+struct _EWebViewGtkHTMLPrivate {
+	GList *requests;
+	GtkUIManager *ui_manager;
+	gchar *selected_uri;
+	GdkPixbufAnimation *cursor_image;
+
+	GtkAction *open_proxy;
+	GtkAction *print_proxy;
+	GtkAction *save_as_proxy;
+
+	GtkTargetList *copy_target_list;
+	GtkTargetList *paste_target_list;
+
+	/* Lockdown Options */
+	guint disable_printing     : 1;
+	guint disable_save_to_disk : 1;
+};
+
+struct _EWebViewGtkHTMLRequest {
+	GFile *file;
+	EWebViewGtkHTML *web_view;
+	GCancellable *cancellable;
+	GInputStream *input_stream;
+	GtkHTMLStream *output_stream;
+	gchar buffer[4096];
+};
+
+enum {
+	PROP_0,
+	PROP_ANIMATE,
+	PROP_CARET_MODE,
+	PROP_COPY_TARGET_LIST,
+	PROP_DISABLE_PRINTING,
+	PROP_DISABLE_SAVE_TO_DISK,
+	PROP_EDITABLE,
+	PROP_INLINE_SPELLING,
+	PROP_MAGIC_LINKS,
+	PROP_MAGIC_SMILEYS,
+	PROP_OPEN_PROXY,
+	PROP_PASTE_TARGET_LIST,
+	PROP_PRINT_PROXY,
+	PROP_SAVE_AS_PROXY,
+	PROP_SELECTED_URI,
+	PROP_CURSOR_IMAGE
+};
+
+enum {
+	COPY_CLIPBOARD,
+	CUT_CLIPBOARD,
+	PASTE_CLIPBOARD,
+	POPUP_EVENT,
+	STATUS_MESSAGE,
+	STOP_LOADING,
+	UPDATE_ACTIONS,
+	PROCESS_MAILTO,
+	LAST_SIGNAL
+};
+
+static gpointer parent_class;
+static guint signals[LAST_SIGNAL];
+
+static const gchar *ui =
+"<ui>"
+"  <popup name='context'>"
+"    <menuitem action='copy-clipboard'/>"
+"    <separator/>"
+"    <placeholder name='custom-actions-1'>"
+"      <menuitem action='open'/>"
+"      <menuitem action='save-as'/>"
+"      <menuitem action='http-open'/>"
+"      <menuitem action='send-message'/>"
+"      <menuitem action='print'/>"
+"    </placeholder>"
+"    <placeholder name='custom-actions-2'>"
+"      <menuitem action='uri-copy'/>"
+"      <menuitem action='mailto-copy'/>"
+"      <menuitem action='image-copy'/>"
+"    </placeholder>"
+"    <placeholder name='custom-actions-3'/>"
+"    <separator/>"
+"    <menuitem action='select-all'/>"
+"  </popup>"
+"</ui>";
+
+/* Forward Declarations */
+static void e_web_view_gtkhtml_alert_sink_init (EAlertSinkInterface *interface);
+static void e_web_view_gtkhtml_selectable_init (ESelectableInterface *interface);
+
+G_DEFINE_TYPE_WITH_CODE (
+	EWebViewGtkHTML,
+	e_web_view_gtkhtml,
+	GTK_TYPE_HTML,
+	G_IMPLEMENT_INTERFACE (
+		E_TYPE_EXTENSIBLE, NULL)
+	G_IMPLEMENT_INTERFACE (
+		E_TYPE_ALERT_SINK,
+		e_web_view_gtkhtml_alert_sink_init)
+	G_IMPLEMENT_INTERFACE (
+		E_TYPE_SELECTABLE,
+		e_web_view_gtkhtml_selectable_init))
+
+static EWebViewGtkHTMLRequest *
+web_view_gtkhtml_request_new (EWebViewGtkHTML *web_view,
+                      const gchar *uri,
+                      GtkHTMLStream *stream)
+{
+	EWebViewGtkHTMLRequest *request;
+	GList *list;
+
+	request = g_slice_new (EWebViewGtkHTMLRequest);
+
+	/* Try to detect file paths posing as URIs. */
+	if (*uri == '/')
+		request->file = g_file_new_for_path (uri);
+	else
+		request->file = g_file_new_for_uri (uri);
+
+	request->web_view = g_object_ref (web_view);
+	request->cancellable = g_cancellable_new ();
+	request->input_stream = NULL;
+	request->output_stream = stream;
+
+	list = request->web_view->priv->requests;
+	list = g_list_prepend (list, request);
+	request->web_view->priv->requests = list;
+
+	return request;
+}
+
+static void
+web_view_gtkhtml_request_free (EWebViewGtkHTMLRequest *request)
+{
+	GList *list;
+
+	list = request->web_view->priv->requests;
+	list = g_list_remove (list, request);
+	request->web_view->priv->requests = list;
+
+	g_object_unref (request->file);
+	g_object_unref (request->web_view);
+	g_object_unref (request->cancellable);
+
+	if (request->input_stream != NULL)
+		g_object_unref (request->input_stream);
+
+	g_slice_free (EWebViewGtkHTMLRequest, request);
+}
+
+static void
+web_view_gtkhtml_request_cancel (EWebViewGtkHTMLRequest *request)
+{
+	g_cancellable_cancel (request->cancellable);
+}
+
+static gboolean
+web_view_gtkhtml_request_check_for_error (EWebViewGtkHTMLRequest *request,
+                                  GError *error)
+{
+	GtkHTML *html;
+	GtkHTMLStream *stream;
+
+	if (error == NULL)
+		return FALSE;
+
+	if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) {
+		/* use this error, but do not close the stream */
+		g_error_free (error);
+		return TRUE;
+	}
+
+	/* XXX Should we log errors that are not cancellations? */
+
+	html = GTK_HTML (request->web_view);
+	stream = request->output_stream;
+
+	gtk_html_end (html, stream, GTK_HTML_STREAM_ERROR);
+	web_view_gtkhtml_request_free (request);
+	g_error_free (error);
+
+	return TRUE;
+}
+
+static void
+web_view_gtkhtml_request_stream_read_cb (GInputStream *input_stream,
+                                 GAsyncResult *result,
+                                 EWebViewGtkHTMLRequest *request)
+{
+	gssize bytes_read;
+	GError *error = NULL;
+
+	bytes_read = g_input_stream_read_finish (input_stream, result, &error);
+
+	if (web_view_gtkhtml_request_check_for_error (request, error))
+		return;
+
+	if (bytes_read == 0) {
+		gtk_html_end (
+			GTK_HTML (request->web_view),
+			request->output_stream, GTK_HTML_STREAM_OK);
+		web_view_gtkhtml_request_free (request);
+		return;
+	}
+
+	gtk_html_write (
+		GTK_HTML (request->web_view),
+		request->output_stream, request->buffer, bytes_read);
+
+	g_input_stream_read_async (
+		request->input_stream, request->buffer,
+		sizeof (request->buffer), G_PRIORITY_DEFAULT,
+		request->cancellable, (GAsyncReadyCallback)
+		web_view_gtkhtml_request_stream_read_cb, request);
+}
+
+static void
+web_view_gtkhtml_request_read_cb (GFile *file,
+                          GAsyncResult *result,
+                          EWebViewGtkHTMLRequest *request)
+{
+	GFileInputStream *input_stream;
+	GError *error = NULL;
+
+	/* Input stream might be NULL, so don't use cast macro. */
+	input_stream = g_file_read_finish (file, result, &error);
+	request->input_stream = (GInputStream *) input_stream;
+
+	if (web_view_gtkhtml_request_check_for_error (request, error))
+		return;
+
+	g_input_stream_read_async (
+		request->input_stream, request->buffer,
+		sizeof (request->buffer), G_PRIORITY_DEFAULT,
+		request->cancellable, (GAsyncReadyCallback)
+		web_view_gtkhtml_request_stream_read_cb, request);
+}
+
+static void
+action_copy_clipboard_cb (GtkAction *action,
+                          EWebViewGtkHTML *web_view)
+{
+	e_web_view_gtkhtml_copy_clipboard (web_view);
+}
+
+static void
+action_http_open_cb (GtkAction *action,
+                     EWebViewGtkHTML *web_view)
+{
+	const gchar *uri;
+	gpointer parent;
+
+	parent = gtk_widget_get_toplevel (GTK_WIDGET (web_view));
+	parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
+
+	uri = e_web_view_gtkhtml_get_selected_uri (web_view);
+	g_return_if_fail (uri != NULL);
+
+	e_show_uri (parent, uri);
+}
+
+static void
+action_mailto_copy_cb (GtkAction *action,
+                       EWebViewGtkHTML *web_view)
+{
+	CamelURL *curl;
+	CamelInternetAddress *inet_addr;
+	GtkClipboard *clipboard;
+	const gchar *uri;
+	gchar *text;
+
+	uri = e_web_view_gtkhtml_get_selected_uri (web_view);
+	g_return_if_fail (uri != NULL);
+
+	/* This should work because we checked it in update_actions(). */
+	curl = camel_url_new (uri, NULL);
+	g_return_if_fail (curl != NULL);
+
+	inet_addr = camel_internet_address_new ();
+	camel_address_decode (CAMEL_ADDRESS (inet_addr), curl->path);
+	text = camel_address_format (CAMEL_ADDRESS (inet_addr));
+	if (text == NULL || *text == '\0')
+		text = g_strdup (uri + strlen ("mailto:";));
+
+	g_object_unref (inet_addr);
+	camel_url_free (curl);
+
+	clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
+	gtk_clipboard_set_text (clipboard, text, -1);
+	gtk_clipboard_store (clipboard);
+
+	clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
+	gtk_clipboard_set_text (clipboard, text, -1);
+	gtk_clipboard_store (clipboard);
+
+	g_free (text);
+}
+
+static void
+action_select_all_cb (GtkAction *action,
+                      EWebViewGtkHTML *web_view)
+{
+	e_web_view_gtkhtml_select_all (web_view);
+}
+
+static void
+action_send_message_cb (GtkAction *action,
+                        EWebViewGtkHTML *web_view)
+{
+	const gchar *uri;
+	gpointer parent;
+	gboolean handled;
+
+	parent = gtk_widget_get_toplevel (GTK_WIDGET (web_view));
+	parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
+
+	uri = e_web_view_gtkhtml_get_selected_uri (web_view);
+	g_return_if_fail (uri != NULL);
+
+	handled = FALSE;
+	g_signal_emit (web_view, signals[PROCESS_MAILTO], 0, uri, &handled);
+
+	if (!handled)
+		e_show_uri (parent, uri);
+}
+
+static void
+action_uri_copy_cb (GtkAction *action,
+                    EWebViewGtkHTML *web_view)
+{
+	GtkClipboard *clipboard;
+	const gchar *uri;
+
+	clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
+	uri = e_web_view_gtkhtml_get_selected_uri (web_view);
+	g_return_if_fail (uri != NULL);
+
+	gtk_clipboard_set_text (clipboard, uri, -1);
+	gtk_clipboard_store (clipboard);
+}
+
+static void
+action_image_copy_cb (GtkAction *action,
+                    EWebViewGtkHTML *web_view)
+{
+	GtkClipboard *clipboard;
+	GdkPixbufAnimation *animation;
+	GdkPixbuf *pixbuf;
+
+	clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
+	animation = e_web_view_gtkhtml_get_cursor_image (web_view);
+	g_return_if_fail (animation != NULL);
+
+	pixbuf = gdk_pixbuf_animation_get_static_image (animation);
+	if (!pixbuf)
+		return;
+
+	gtk_clipboard_set_image (clipboard, pixbuf);
+	gtk_clipboard_store (clipboard);
+}
+
+static GtkActionEntry uri_entries[] = {
+
+	{ "uri-copy",
+	  GTK_STOCK_COPY,
+	  N_("_Copy Link Location"),
+	  NULL,
+	  N_("Copy the link to the clipboard"),
+	  G_CALLBACK (action_uri_copy_cb) }
+};
+
+static GtkActionEntry http_entries[] = {
+
+	{ "http-open",
+	  "emblem-web",
+	  N_("_Open Link in Browser"),
+	  NULL,
+	  N_("Open the link in a web browser"),
+	  G_CALLBACK (action_http_open_cb) }
+};
+
+static GtkActionEntry mailto_entries[] = {
+
+	{ "mailto-copy",
+	  GTK_STOCK_COPY,
+	  N_("_Copy Email Address"),
+	  NULL,
+	  N_("Copy the email address to the clipboard"),
+	  G_CALLBACK (action_mailto_copy_cb) },
+
+	{ "send-message",
+	  "mail-message-new",
+	  N_("_Send New Message To..."),
+	  NULL,
+	  N_("Send a mail message to this address"),
+	  G_CALLBACK (action_send_message_cb) }
+};
+
+static GtkActionEntry image_entries[] = {
+
+	{ "image-copy",
+	  GTK_STOCK_COPY,
+	  N_("_Copy Image"),
+	  NULL,
+	  N_("Copy the image to the clipboard"),
+	  G_CALLBACK (action_image_copy_cb) }
+};
+
+static GtkActionEntry selection_entries[] = {
+
+	{ "copy-clipboard",
+	  GTK_STOCK_COPY,
+	  NULL,
+	  NULL,
+	  N_("Copy the selection"),
+	  G_CALLBACK (action_copy_clipboard_cb) },
+};
+
+static GtkActionEntry standard_entries[] = {
+
+	{ "select-all",
+	  GTK_STOCK_SELECT_ALL,
+	  NULL,
+	  NULL,
+	  N_("Select all text and images"),
+	  G_CALLBACK (action_select_all_cb) }
+};
+
+static gboolean
+web_view_gtkhtml_button_press_event_cb (EWebViewGtkHTML *web_view,
+                                GdkEventButton *event,
+                                GtkHTML *frame)
+{
+	gboolean event_handled = FALSE;
+	gchar *uri = NULL;
+
+	if (event) {
+		GdkPixbufAnimation *anim;
+
+		if (frame == NULL)
+			frame = GTK_HTML (web_view);
+
+		anim = gtk_html_get_image_at (frame, event->x, event->y);
+		e_web_view_gtkhtml_set_cursor_image (web_view, anim);
+		if (anim != NULL)
+			g_object_unref (anim);
+	}
+
+	if (event != NULL && event->button != 3)
+		return FALSE;
+
+	/* Only extract a URI if no selection is active.  Selected text
+	 * implies the user is more likely to want to copy the selection
+	 * to the clipboard than open a link within the selection. */
+	if (!e_web_view_gtkhtml_is_selection_active (web_view))
+		uri = e_web_view_gtkhtml_extract_uri (web_view, event, frame);
+
+	if (uri != NULL && g_str_has_prefix (uri, "##")) {
+		g_free (uri);
+		return FALSE;
+	}
+
+	g_signal_emit (
+		web_view, signals[POPUP_EVENT], 0,
+		event, uri, &event_handled);
+
+	g_free (uri);
+
+	return event_handled;
+}
+
+static void
+web_view_gtkhtml_menu_item_select_cb (EWebViewGtkHTML *web_view,
+                              GtkWidget *widget)
+{
+	GtkAction *action;
+	GtkActivatable *activatable;
+	const gchar *tooltip;
+
+	activatable = GTK_ACTIVATABLE (widget);
+	action = gtk_activatable_get_related_action (activatable);
+	tooltip = gtk_action_get_tooltip (action);
+
+	if (tooltip == NULL)
+		return;
+
+	e_web_view_gtkhtml_status_message (web_view, tooltip);
+}
+
+static void
+web_view_gtkhtml_menu_item_deselect_cb (EWebViewGtkHTML *web_view)
+{
+	e_web_view_gtkhtml_status_message (web_view, NULL);
+}
+
+static void
+web_view_gtkhtml_connect_proxy_cb (EWebViewGtkHTML *web_view,
+                           GtkAction *action,
+                           GtkWidget *proxy)
+{
+	if (!GTK_IS_MENU_ITEM (proxy))
+		return;
+
+	g_signal_connect_swapped (
+		proxy, "select",
+		G_CALLBACK (web_view_gtkhtml_menu_item_select_cb), web_view);
+
+	g_signal_connect_swapped (
+		proxy, "deselect",
+		G_CALLBACK (web_view_gtkhtml_menu_item_deselect_cb), web_view);
+}
+
+static void
+web_view_gtkhtml_set_property (GObject *object,
+                       guint property_id,
+                       const GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_ANIMATE:
+			e_web_view_gtkhtml_set_animate (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_CARET_MODE:
+			e_web_view_gtkhtml_set_caret_mode (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_DISABLE_PRINTING:
+			e_web_view_gtkhtml_set_disable_printing (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_DISABLE_SAVE_TO_DISK:
+			e_web_view_gtkhtml_set_disable_save_to_disk (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_EDITABLE:
+			e_web_view_gtkhtml_set_editable (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_INLINE_SPELLING:
+			e_web_view_gtkhtml_set_inline_spelling (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_MAGIC_LINKS:
+			e_web_view_gtkhtml_set_magic_links (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_MAGIC_SMILEYS:
+			e_web_view_gtkhtml_set_magic_smileys (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_boolean (value));
+			return;
+
+		case PROP_OPEN_PROXY:
+			e_web_view_gtkhtml_set_open_proxy (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_object (value));
+			return;
+
+		case PROP_PRINT_PROXY:
+			e_web_view_gtkhtml_set_print_proxy (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_object (value));
+			return;
+
+		case PROP_SAVE_AS_PROXY:
+			e_web_view_gtkhtml_set_save_as_proxy (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_object (value));
+			return;
+
+		case PROP_SELECTED_URI:
+			e_web_view_gtkhtml_set_selected_uri (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_string (value));
+			return;
+		case PROP_CURSOR_IMAGE:
+			e_web_view_gtkhtml_set_cursor_image (
+				E_WEB_VIEW_GTKHTML (object),
+				g_value_get_object (value));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+web_view_gtkhtml_get_property (GObject *object,
+                       guint property_id,
+                       GValue *value,
+                       GParamSpec *pspec)
+{
+	switch (property_id) {
+		case PROP_ANIMATE:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_animate (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_CARET_MODE:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_caret_mode (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_COPY_TARGET_LIST:
+			g_value_set_boxed (
+				value, e_web_view_gtkhtml_get_copy_target_list (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_DISABLE_PRINTING:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_disable_printing (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_DISABLE_SAVE_TO_DISK:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_disable_save_to_disk (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_EDITABLE:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_editable (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_INLINE_SPELLING:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_inline_spelling (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_MAGIC_LINKS:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_magic_links (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_MAGIC_SMILEYS:
+			g_value_set_boolean (
+				value, e_web_view_gtkhtml_get_magic_smileys (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_OPEN_PROXY:
+			g_value_set_object (
+				value, e_web_view_gtkhtml_get_open_proxy (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_PASTE_TARGET_LIST:
+			g_value_set_boxed (
+				value, e_web_view_gtkhtml_get_paste_target_list (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_PRINT_PROXY:
+			g_value_set_object (
+				value, e_web_view_gtkhtml_get_print_proxy (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_SAVE_AS_PROXY:
+			g_value_set_object (
+				value, e_web_view_gtkhtml_get_save_as_proxy (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_SELECTED_URI:
+			g_value_set_string (
+				value, e_web_view_gtkhtml_get_selected_uri (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+
+		case PROP_CURSOR_IMAGE:
+			g_value_set_object (
+				value, e_web_view_gtkhtml_get_cursor_image (
+				E_WEB_VIEW_GTKHTML (object)));
+			return;
+	}
+
+	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+web_view_gtkhtml_dispose (GObject *object)
+{
+	EWebViewGtkHTMLPrivate *priv;
+
+	priv = E_WEB_VIEW_GTKHTML_GET_PRIVATE (object);
+
+	if (priv->ui_manager != NULL) {
+		g_object_unref (priv->ui_manager);
+		priv->ui_manager = NULL;
+	}
+
+	if (priv->open_proxy != NULL) {
+		g_object_unref (priv->open_proxy);
+		priv->open_proxy = NULL;
+	}
+
+	if (priv->print_proxy != NULL) {
+		g_object_unref (priv->print_proxy);
+		priv->print_proxy = NULL;
+	}
+
+	if (priv->save_as_proxy != NULL) {
+		g_object_unref (priv->save_as_proxy);
+		priv->save_as_proxy = NULL;
+	}
+
+	if (priv->copy_target_list != NULL) {
+		gtk_target_list_unref (priv->copy_target_list);
+		priv->copy_target_list = NULL;
+	}
+
+	if (priv->paste_target_list != NULL) {
+		gtk_target_list_unref (priv->paste_target_list);
+		priv->paste_target_list = NULL;
+	}
+
+	if (priv->cursor_image != NULL) {
+		g_object_unref (priv->cursor_image);
+		priv->cursor_image = NULL;
+	}
+
+	/* Chain up to parent's dispose() method. */
+	G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+web_view_gtkhtml_finalize (GObject *object)
+{
+	EWebViewGtkHTMLPrivate *priv;
+
+	priv = E_WEB_VIEW_GTKHTML_GET_PRIVATE (object);
+
+	/* All URI requests should be complete or cancelled by now. */
+	if (priv->requests != NULL)
+		g_warning ("Finalizing EWebViewGtkHTML with active URI requests");
+
+	g_free (priv->selected_uri);
+
+	/* Chain up to parent's finalize() method. */
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+web_view_gtkhtml_constructed (GObject *object)
+{
+#ifndef G_OS_WIN32
+	GSettings *settings;
+
+	settings = g_settings_new ("org.gnome.desktop.lockdown");
+
+	g_settings_bind (
+		settings, "disable-printing",
+		object, "disable-printing",
+		G_SETTINGS_BIND_GET);
+
+	g_settings_bind (
+		settings, "disable-save-to-disk",
+		object, "disable-save-to-disk",
+		G_SETTINGS_BIND_GET);
+
+	g_object_unref (settings);
+#endif
+
+	/* Chain up to parent's constructed() method. */
+	G_OBJECT_CLASS (parent_class)->constructed (object);
+}
+
+static gboolean
+web_view_gtkhtml_button_press_event (GtkWidget *widget,
+                             GdkEventButton *event)
+{
+	GtkWidgetClass *widget_class;
+	EWebViewGtkHTML *web_view;
+
+	web_view = E_WEB_VIEW_GTKHTML (widget);
+
+	if (web_view_gtkhtml_button_press_event_cb (web_view, event, NULL))
+		return TRUE;
+
+	/* Chain up to parent's button_press_event() method. */
+	widget_class = GTK_WIDGET_CLASS (parent_class);
+	return widget_class->button_press_event (widget, event);
+}
+
+static gboolean
+web_view_gtkhtml_scroll_event (GtkWidget *widget,
+                       GdkEventScroll *event)
+{
+	if (event->state & GDK_CONTROL_MASK) {
+		switch (event->direction) {
+			case GDK_SCROLL_UP:
+				gtk_html_zoom_in (GTK_HTML (widget));
+				return TRUE;
+			case GDK_SCROLL_DOWN:
+				gtk_html_zoom_out (GTK_HTML (widget));
+				return TRUE;
+			default:
+				break;
+		}
+	}
+
+	return FALSE;
+}
+
+static void
+web_view_gtkhtml_url_requested (GtkHTML *html,
+                        const gchar *uri,
+                        GtkHTMLStream *stream)
+{
+	EWebViewGtkHTMLRequest *request;
+
+	request = web_view_gtkhtml_request_new (E_WEB_VIEW_GTKHTML (html), uri, stream);
+
+	g_file_read_async (
+		request->file, G_PRIORITY_DEFAULT,
+		request->cancellable, (GAsyncReadyCallback)
+		web_view_gtkhtml_request_read_cb, request);
+}
+
+static void
+web_view_gtkhtml_gtkhtml_link_clicked (GtkHTML *html,
+                               const gchar *uri)
+{
+	EWebViewGtkHTMLClass *class;
+	EWebViewGtkHTML *web_view;
+
+	web_view = E_WEB_VIEW_GTKHTML (html);
+
+	class = E_WEB_VIEW_GTKHTML_GET_CLASS (web_view);
+	g_return_if_fail (class->link_clicked != NULL);
+
+	class->link_clicked (web_view, uri);
+}
+
+static void
+web_view_gtkhtml_on_url (GtkHTML *html,
+                 const gchar *uri)
+{
+	EWebViewGtkHTMLClass *class;
+	EWebViewGtkHTML *web_view;
+
+	web_view = E_WEB_VIEW_GTKHTML (html);
+
+	class = E_WEB_VIEW_GTKHTML_GET_CLASS (web_view);
+	g_return_if_fail (class->hovering_over_link != NULL);
+
+	/* XXX WebKit would supply a title here. */
+	class->hovering_over_link (web_view, NULL, uri);
+}
+
+static void
+web_view_gtkhtml_iframe_created (GtkHTML *html,
+                         GtkHTML *iframe)
+{
+	g_signal_connect_swapped (
+		iframe, "button-press-event",
+		G_CALLBACK (web_view_gtkhtml_button_press_event_cb), html);
+}
+
+static gchar *
+web_view_gtkhtml_extract_uri (EWebViewGtkHTML *web_view,
+                      GdkEventButton *event,
+                      GtkHTML *html)
+{
+	gchar *uri;
+
+	if (event != NULL)
+		uri = gtk_html_get_url_at (html, event->x, event->y);
+	else
+		uri = gtk_html_get_cursor_url (html);
+
+	return uri;
+}
+
+static void
+web_view_gtkhtml_hovering_over_link (EWebViewGtkHTML *web_view,
+                             const gchar *title,
+                             const gchar *uri)
+{
+	CamelInternetAddress *address;
+	CamelURL *curl;
+	const gchar *format = NULL;
+	gchar *message = NULL;
+	gchar *who;
+
+	if (uri == NULL || *uri == '\0')
+		goto exit;
+
+	if (g_str_has_prefix (uri, "mailto:";))
+		format = _("Click to mail %s");
+	else if (g_str_has_prefix (uri, "callto:"))
+		format = _("Click to call %s");
+	else if (g_str_has_prefix (uri, "h323:"))
+		format = _("Click to call %s");
+	else if (g_str_has_prefix (uri, "sip:"))
+		format = _("Click to call %s");
+	else if (g_str_has_prefix (uri, "##"))
+		message = g_strdup (_("Click to hide/unhide addresses"));
+	else
+		message = g_strdup_printf (_("Click to open %s"), uri);
+
+	if (format == NULL)
+		goto exit;
+
+	/* XXX Use something other than Camel here.  Surely
+	 *     there's other APIs around that can do this. */
+	curl = camel_url_new (uri, NULL);
+	address = camel_internet_address_new ();
+	camel_address_decode (CAMEL_ADDRESS (address), curl->path);
+	who = camel_address_format (CAMEL_ADDRESS (address));
+	g_object_unref (address);
+	camel_url_free (curl);
+
+	if (who == NULL)
+		who = g_strdup (strchr (uri, ':') + 1);
+
+	message = g_strdup_printf (format, who);
+
+	g_free (who);
+
+exit:
+	e_web_view_gtkhtml_status_message (web_view, message);
+
+	g_free (message);
+}
+
+static void
+web_view_gtkhtml_link_clicked (EWebViewGtkHTML *web_view,
+                       const gchar *uri)
+{
+	gpointer parent;
+
+	parent = gtk_widget_get_toplevel (GTK_WIDGET (web_view));
+	parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
+
+	e_show_uri (parent, uri);
+}
+
+static void
+web_view_gtkhtml_load_string (EWebViewGtkHTML *web_view,
+                      const gchar *string)
+{
+	if (string != NULL && *string != '\0')
+		gtk_html_load_from_string (GTK_HTML (web_view), string, -1);
+	else
+		e_web_view_gtkhtml_clear (web_view);
+}
+
+static void
+web_view_gtkhtml_copy_clipboard (EWebViewGtkHTML *web_view)
+{
+	gtk_html_command (GTK_HTML (web_view), "copy");
+}
+
+static void
+web_view_gtkhtml_cut_clipboard (EWebViewGtkHTML *web_view)
+{
+	if (e_web_view_gtkhtml_get_editable (web_view))
+		gtk_html_command (GTK_HTML (web_view), "cut");
+}
+
+static void
+web_view_gtkhtml_paste_clipboard (EWebViewGtkHTML *web_view)
+{
+	if (e_web_view_gtkhtml_get_editable (web_view))
+		gtk_html_command (GTK_HTML (web_view), "paste");
+}
+
+static gboolean
+web_view_gtkhtml_popup_event (EWebViewGtkHTML *web_view,
+                      GdkEventButton *event,
+                      const gchar *uri)
+{
+	e_web_view_gtkhtml_set_selected_uri (web_view, uri);
+	e_web_view_gtkhtml_show_popup_menu (web_view, event, NULL, NULL);
+
+	return TRUE;
+}
+
+static void
+web_view_gtkhtml_stop_loading (EWebViewGtkHTML *web_view)
+{
+	g_list_foreach (
+		web_view->priv->requests, (GFunc)
+		web_view_gtkhtml_request_cancel, NULL);
+
+	gtk_html_stop (GTK_HTML (web_view));
+}
+
+static void
+web_view_gtkhtml_update_actions (EWebViewGtkHTML *web_view)
+{
+	GtkActionGroup *action_group;
+	gboolean have_selection;
+	gboolean scheme_is_http = FALSE;
+	gboolean scheme_is_mailto = FALSE;
+	gboolean uri_is_valid = FALSE;
+	gboolean has_cursor_image;
+	gboolean visible;
+	const gchar *group_name;
+	const gchar *uri;
+
+	uri = e_web_view_gtkhtml_get_selected_uri (web_view);
+	have_selection = e_web_view_gtkhtml_is_selection_active (web_view);
+	has_cursor_image = e_web_view_gtkhtml_get_cursor_image (web_view) != NULL;
+
+	/* Parse the URI early so we know if the actions will work. */
+	if (uri != NULL) {
+		CamelURL *curl;
+
+		curl = camel_url_new (uri, NULL);
+		uri_is_valid = (curl != NULL);
+		camel_url_free (curl);
+
+		scheme_is_http =
+			(g_ascii_strncasecmp (uri, "http:", 5) == 0) ||
+			(g_ascii_strncasecmp (uri, "https:", 6) == 0);
+
+		scheme_is_mailto =
+			(g_ascii_strncasecmp (uri, "mailto:";, 7) == 0);
+	}
+
+	/* Allow copying the URI even if it's malformed. */
+	group_name = "uri";
+	visible = (uri != NULL) && !scheme_is_mailto;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "http";
+	visible = uri_is_valid && scheme_is_http;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "mailto";
+	visible = uri_is_valid && scheme_is_mailto;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "image";
+	visible = has_cursor_image;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "selection";
+	visible = have_selection;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "standard";
+	visible = (uri == NULL);
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "lockdown-printing";
+	visible = (uri == NULL) && !web_view->priv->disable_printing;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+
+	group_name = "lockdown-save-to-disk";
+	visible = (uri == NULL) && !web_view->priv->disable_save_to_disk;
+	action_group = e_web_view_gtkhtml_get_action_group (web_view, group_name);
+	gtk_action_group_set_visible (action_group, visible);
+}
+
+static void
+web_view_gtkhtml_submit_alert (EAlertSink *alert_sink,
+                       EAlert *alert)
+{
+	GtkIconInfo *icon_info;
+	EWebViewGtkHTML *web_view;
+	GtkWidget *dialog;
+	GString *buffer;
+	const gchar *icon_name = NULL;
+	const gchar *filename;
+	gpointer parent;
+	gchar *icon_uri;
+	gint size = 0;
+	GError *error = NULL;
+
+	web_view = E_WEB_VIEW_GTKHTML (alert_sink);
+
+	parent = gtk_widget_get_toplevel (GTK_WIDGET (web_view));
+	parent = gtk_widget_is_toplevel (parent) ? parent : NULL;
+
+	/* We use equivalent named icons instead of stock IDs,
+	 * since it's easier to get the filename of the icon. */
+	switch (e_alert_get_message_type (alert)) {
+		case GTK_MESSAGE_INFO:
+			icon_name = "dialog-information";
+			break;
+
+		case GTK_MESSAGE_WARNING:
+			icon_name = "dialog-warning";
+			break;
+
+		case GTK_MESSAGE_ERROR:
+			icon_name = "dialog-error";
+			break;
+
+		default:
+			dialog = e_alert_dialog_new (parent, alert);
+			gtk_dialog_run (GTK_DIALOG (dialog));
+			gtk_widget_destroy (dialog);
+			return;
+	}
+
+	gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &size, NULL);
+
+	icon_info = gtk_icon_theme_lookup_icon (
+		gtk_icon_theme_get_default (),
+		icon_name, size, GTK_ICON_LOOKUP_NO_SVG);
+	g_return_if_fail (icon_info != NULL);
+
+	filename = gtk_icon_info_get_filename (icon_info);
+	icon_uri = g_filename_to_uri (filename, NULL, &error);
+
+	if (error != NULL) {
+		g_warning ("%s", error->message);
+		g_clear_error (&error);
+	}
+
+	buffer = g_string_sized_new (512);
+
+	g_string_append (
+		buffer,
+		"<html>"
+		"<head>"
+		"<meta http-equiv=\"content-type\""
+		" content=\"text/html; charset=utf-8\">"
+		"</head>"
+		"<body>");
+
+	g_string_append (
+		buffer,
+		"<table bgcolor='#000000' width='100%'"
+		" cellpadding='1' cellspacing='0'>"
+		"<tr>"
+		"<td>"
+		"<table bgcolor='#dddddd' width='100%' cellpadding='6'>"
+		"<tr>");
+
+	g_string_append_printf (
+		buffer,
+		"<tr>"
+		"<td valign='top'>"
+		"<img src='%s'/>"
+		"</td>"
+		"<td align='left' width='100%%'>"
+		"<h3>%s</h3>"
+		"%s"
+		"</td>"
+		"</tr>",
+		icon_uri,
+		e_alert_get_primary_text (alert),
+		e_alert_get_secondary_text (alert));
+
+	g_string_append (
+		buffer,
+		"</table>"
+		"</td>"
+		"</tr>"
+		"</table>"
+		"</body>"
+		"</html>");
+
+	e_web_view_gtkhtml_load_string (web_view, buffer->str);
+
+	g_string_free (buffer, TRUE);
+
+	gtk_icon_info_free (icon_info);
+	g_free (icon_uri);
+}
+
+static void
+web_view_gtkhtml_selectable_update_actions (ESelectable *selectable,
+                                    EFocusTracker *focus_tracker,
+                                    GdkAtom *clipboard_targets,
+                                    gint n_clipboard_targets)
+{
+	EWebViewGtkHTML *web_view;
+	GtkAction *action;
+	/*GtkTargetList *target_list;*/
+	gboolean can_paste = FALSE;
+	gboolean editable;
+	gboolean have_selection;
+	gboolean sensitive;
+	const gchar *tooltip;
+	/*gint ii;*/
+
+	web_view = E_WEB_VIEW_GTKHTML (selectable);
+	editable = e_web_view_gtkhtml_get_editable (web_view);
+	have_selection = e_web_view_gtkhtml_is_selection_active (web_view);
+
+	/* XXX GtkHtml implements its own clipboard instead of using
+	 *     GDK_SELECTION_CLIPBOARD, so we don't get notifications
+	 *     when the clipboard contents change.  The logic below
+	 *     is what we would do if GtkHtml worked properly.
+	 *     Instead, we need to keep the Paste action sensitive so
+	 *     its accelerator overrides GtkHtml's key binding. */
+#if 0
+	target_list = e_selectable_get_paste_target_list (selectable);
+	for (ii = 0; ii < n_clipboard_targets && !can_paste; ii++)
+		can_paste = gtk_target_list_find (
+			target_list, clipboard_targets[ii], NULL);
+#endif
+	can_paste = TRUE;
+
+	action = e_focus_tracker_get_cut_clipboard_action (focus_tracker);
+	sensitive = editable && have_selection;
+	tooltip = _("Cut the selection");
+	gtk_action_set_sensitive (action, sensitive);
+	gtk_action_set_tooltip (action, tooltip);
+
+	action = e_focus_tracker_get_copy_clipboard_action (focus_tracker);
+	sensitive = have_selection;
+	tooltip = _("Copy the selection");
+	gtk_action_set_sensitive (action, sensitive);
+	gtk_action_set_tooltip (action, tooltip);
+
+	action = e_focus_tracker_get_paste_clipboard_action (focus_tracker);
+	sensitive = editable && can_paste;
+	tooltip = _("Paste the clipboard");
+	gtk_action_set_sensitive (action, sensitive);
+	gtk_action_set_tooltip (action, tooltip);
+
+	action = e_focus_tracker_get_select_all_action (focus_tracker);
+	sensitive = TRUE;
+	tooltip = _("Select all text and images");
+	gtk_action_set_sensitive (action, sensitive);
+	gtk_action_set_tooltip (action, tooltip);
+}
+
+static void
+web_view_gtkhtml_selectable_cut_clipboard (ESelectable *selectable)
+{
+	e_web_view_gtkhtml_cut_clipboard (E_WEB_VIEW_GTKHTML (selectable));
+}
+
+static void
+web_view_gtkhtml_selectable_copy_clipboard (ESelectable *selectable)
+{
+	e_web_view_gtkhtml_copy_clipboard (E_WEB_VIEW_GTKHTML (selectable));
+}
+
+static void
+web_view_gtkhtml_selectable_paste_clipboard (ESelectable *selectable)
+{
+	e_web_view_gtkhtml_paste_clipboard (E_WEB_VIEW_GTKHTML (selectable));
+}
+
+static void
+web_view_gtkhtml_selectable_select_all (ESelectable *selectable)
+{
+	e_web_view_gtkhtml_select_all (E_WEB_VIEW_GTKHTML (selectable));
+}
+
+static void
+e_web_view_gtkhtml_class_init (EWebViewGtkHTMLClass *class)
+{
+	GObjectClass *object_class;
+	GtkWidgetClass *widget_class;
+	GtkHTMLClass *html_class;
+
+	parent_class = g_type_class_peek_parent (class);
+	g_type_class_add_private (class, sizeof (EWebViewGtkHTMLPrivate));
+
+	object_class = G_OBJECT_CLASS (class);
+	object_class->set_property = web_view_gtkhtml_set_property;
+	object_class->get_property = web_view_gtkhtml_get_property;
+	object_class->dispose = web_view_gtkhtml_dispose;
+	object_class->finalize = web_view_gtkhtml_finalize;
+	object_class->constructed = web_view_gtkhtml_constructed;
+
+	widget_class = GTK_WIDGET_CLASS (class);
+	widget_class->button_press_event = web_view_gtkhtml_button_press_event;
+	widget_class->scroll_event = web_view_gtkhtml_scroll_event;
+
+	html_class = GTK_HTML_CLASS (class);
+	html_class->url_requested = web_view_gtkhtml_url_requested;
+	html_class->link_clicked = web_view_gtkhtml_gtkhtml_link_clicked;
+	html_class->on_url = web_view_gtkhtml_on_url;
+	html_class->iframe_created = web_view_gtkhtml_iframe_created;
+
+	class->extract_uri = web_view_gtkhtml_extract_uri;
+	class->hovering_over_link = web_view_gtkhtml_hovering_over_link;
+	class->link_clicked = web_view_gtkhtml_link_clicked;
+	class->load_string = web_view_gtkhtml_load_string;
+	class->copy_clipboard = web_view_gtkhtml_copy_clipboard;
+	class->cut_clipboard = web_view_gtkhtml_cut_clipboard;
+	class->paste_clipboard = web_view_gtkhtml_paste_clipboard;
+	class->popup_event = web_view_gtkhtml_popup_event;
+	class->stop_loading = web_view_gtkhtml_stop_loading;
+	class->update_actions = web_view_gtkhtml_update_actions;
+
+	g_object_class_install_property (
+		object_class,
+		PROP_ANIMATE,
+		g_param_spec_boolean (
+			"animate",
+			"Animate Images",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_CARET_MODE,
+		g_param_spec_boolean (
+			"caret-mode",
+			"Caret Mode",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	/* Inherited from ESelectableInterface */
+	g_object_class_override_property (
+		object_class,
+		PROP_COPY_TARGET_LIST,
+		"copy-target-list");
+
+	g_object_class_install_property (
+		object_class,
+		PROP_DISABLE_PRINTING,
+		g_param_spec_boolean (
+			"disable-printing",
+			"Disable Printing",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_DISABLE_SAVE_TO_DISK,
+		g_param_spec_boolean (
+			"disable-save-to-disk",
+			"Disable Save-to-Disk",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE |
+			G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_EDITABLE,
+		g_param_spec_boolean (
+			"editable",
+			"Editable",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_INLINE_SPELLING,
+		g_param_spec_boolean (
+			"inline-spelling",
+			"Inline Spelling",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_MAGIC_LINKS,
+		g_param_spec_boolean (
+			"magic-links",
+			"Magic Links",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_MAGIC_SMILEYS,
+		g_param_spec_boolean (
+			"magic-smileys",
+			"Magic Smileys",
+			NULL,
+			FALSE,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_OPEN_PROXY,
+		g_param_spec_object (
+			"open-proxy",
+			"Open Proxy",
+			NULL,
+			GTK_TYPE_ACTION,
+			G_PARAM_READWRITE));
+
+	/* Inherited from ESelectableInterface */
+	g_object_class_override_property (
+		object_class,
+		PROP_PASTE_TARGET_LIST,
+		"paste-target-list");
+
+	g_object_class_install_property (
+		object_class,
+		PROP_PRINT_PROXY,
+		g_param_spec_object (
+			"print-proxy",
+			"Print Proxy",
+			NULL,
+			GTK_TYPE_ACTION,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_SAVE_AS_PROXY,
+		g_param_spec_object (
+			"save-as-proxy",
+			"Save As Proxy",
+			NULL,
+			GTK_TYPE_ACTION,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_SELECTED_URI,
+		g_param_spec_string (
+			"selected-uri",
+			"Selected URI",
+			NULL,
+			NULL,
+			G_PARAM_READWRITE));
+
+	g_object_class_install_property (
+		object_class,
+		PROP_CURSOR_IMAGE,
+		g_param_spec_object (
+			"cursor-image",
+			"Image animation at the mouse cursor",
+			NULL,
+			GDK_TYPE_PIXBUF_ANIMATION,
+			G_PARAM_READWRITE));
+
+	signals[COPY_CLIPBOARD] = g_signal_new (
+		"copy-clipboard",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, copy_clipboard),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[CUT_CLIPBOARD] = g_signal_new (
+		"cut-clipboard",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, cut_clipboard),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[PASTE_CLIPBOARD] = g_signal_new (
+		"paste-clipboard",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, paste_clipboard),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[POPUP_EVENT] = g_signal_new (
+		"popup-event",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, popup_event),
+		g_signal_accumulator_true_handled, NULL,
+		e_marshal_BOOLEAN__BOXED_STRING,
+		G_TYPE_BOOLEAN, 2,
+		GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
+		G_TYPE_STRING);
+
+	signals[STATUS_MESSAGE] = g_signal_new (
+		"status-message",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, status_message),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__STRING,
+		G_TYPE_NONE, 1,
+		G_TYPE_STRING);
+
+	signals[STOP_LOADING] = g_signal_new (
+		"stop-loading",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, stop_loading),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	signals[UPDATE_ACTIONS] = g_signal_new (
+		"update-actions",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, update_actions),
+		NULL, NULL,
+		g_cclosure_marshal_VOID__VOID,
+		G_TYPE_NONE, 0);
+
+	/* return TRUE when a signal handler processed the mailto URI */
+	signals[PROCESS_MAILTO] = g_signal_new (
+		"process-mailto",
+		G_TYPE_FROM_CLASS (class),
+		G_SIGNAL_RUN_LAST,
+		G_STRUCT_OFFSET (EWebViewGtkHTMLClass, process_mailto),
+		NULL, NULL,
+		e_marshal_BOOLEAN__STRING,
+		G_TYPE_BOOLEAN, 1, G_TYPE_STRING);
+}
+
+static void
+e_web_view_gtkhtml_alert_sink_init (EAlertSinkInterface *interface)
+{
+	interface->submit_alert = web_view_gtkhtml_submit_alert;
+}
+
+static void
+e_web_view_gtkhtml_selectable_init (ESelectableInterface *interface)
+{
+	interface->update_actions = web_view_gtkhtml_selectable_update_actions;
+	interface->cut_clipboard = web_view_gtkhtml_selectable_cut_clipboard;
+	interface->copy_clipboard = web_view_gtkhtml_selectable_copy_clipboard;
+	interface->paste_clipboard = web_view_gtkhtml_selectable_paste_clipboard;
+	interface->select_all = web_view_gtkhtml_selectable_select_all;
+}
+
+static void
+e_web_view_gtkhtml_init (EWebViewGtkHTML *web_view)
+{
+	GtkUIManager *ui_manager;
+	GtkActionGroup *action_group;
+	GtkTargetList *target_list;
+	EPopupAction *popup_action;
+	const gchar *domain = GETTEXT_PACKAGE;
+	const gchar *id;
+	GError *error = NULL;
+
+	web_view->priv = E_WEB_VIEW_GTKHTML_GET_PRIVATE (web_view);
+
+	ui_manager = gtk_ui_manager_new ();
+	web_view->priv->ui_manager = ui_manager;
+
+	g_signal_connect_swapped (
+		ui_manager, "connect-proxy",
+		G_CALLBACK (web_view_gtkhtml_connect_proxy_cb), web_view);
+
+	target_list = gtk_target_list_new (NULL, 0);
+	web_view->priv->copy_target_list = target_list;
+
+	target_list = gtk_target_list_new (NULL, 0);
+	web_view->priv->paste_target_list = target_list;
+
+	action_group = gtk_action_group_new ("uri");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, uri_entries,
+		G_N_ELEMENTS (uri_entries), web_view);
+
+	action_group = gtk_action_group_new ("http");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, http_entries,
+		G_N_ELEMENTS (http_entries), web_view);
+
+	action_group = gtk_action_group_new ("mailto");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, mailto_entries,
+		G_N_ELEMENTS (mailto_entries), web_view);
+
+	action_group = gtk_action_group_new ("image");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, image_entries,
+		G_N_ELEMENTS (image_entries), web_view);
+
+	action_group = gtk_action_group_new ("selection");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, selection_entries,
+		G_N_ELEMENTS (selection_entries), web_view);
+
+	action_group = gtk_action_group_new ("standard");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	gtk_action_group_add_actions (
+		action_group, standard_entries,
+		G_N_ELEMENTS (standard_entries), web_view);
+
+	popup_action = e_popup_action_new ("open");
+	gtk_action_group_add_action (action_group, GTK_ACTION (popup_action));
+	g_object_unref (popup_action);
+
+	g_object_bind_property (
+		web_view, "open-proxy",
+		popup_action, "related-action",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	/* Support lockdown. */
+
+	action_group = gtk_action_group_new ("lockdown-printing");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	popup_action = e_popup_action_new ("print");
+	gtk_action_group_add_action (action_group, GTK_ACTION (popup_action));
+	g_object_unref (popup_action);
+
+	g_object_bind_property (
+		web_view, "print-proxy",
+		popup_action, "related-action",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	action_group = gtk_action_group_new ("lockdown-save-to-disk");
+	gtk_action_group_set_translation_domain (action_group, domain);
+	gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
+	g_object_unref (action_group);
+
+	popup_action = e_popup_action_new ("save-as");
+	gtk_action_group_add_action (action_group, GTK_ACTION (popup_action));
+	g_object_unref (popup_action);
+
+	g_object_bind_property (
+		web_view, "save-as-proxy",
+		popup_action, "related-action",
+		G_BINDING_BIDIRECTIONAL |
+		G_BINDING_SYNC_CREATE);
+
+	/* Because we are loading from a hard-coded string, there is
+	 * no chance of I/O errors.  Failure here implies a malformed
+	 * UI definition.  Full stop. */
+	gtk_ui_manager_add_ui_from_string (ui_manager, ui, -1, &error);
+	if (error != NULL)
+		g_error ("%s", error->message);
+
+	id = "org.gnome.evolution.webview";
+	e_plugin_ui_register_manager (ui_manager, id, web_view);
+	e_plugin_ui_enable_manager (ui_manager, id);
+
+	e_extensible_load_extensions (E_EXTENSIBLE (web_view));
+}
+
+GtkWidget *
+e_web_view_gtkhtml_new (void)
+{
+	return g_object_new (E_TYPE_WEB_VIEW_GTKHTML, NULL);
+}
+
+void
+e_web_view_gtkhtml_clear (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_load_empty (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_load_string (EWebViewGtkHTML *web_view,
+                        const gchar *string)
+{
+	EWebViewGtkHTMLClass *class;
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	class = E_WEB_VIEW_GTKHTML_GET_CLASS (web_view);
+	g_return_if_fail (class->load_string != NULL);
+
+	class->load_string (web_view, string);
+}
+
+gboolean
+e_web_view_gtkhtml_get_animate (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_animate(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_animate (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_animate (EWebViewGtkHTML *web_view,
+                        gboolean animate)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_animate()
+	 *     so we can get a "notify::animate" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_animate (GTK_HTML (web_view), animate);
+
+	g_object_notify (G_OBJECT (web_view), "animate");
+}
+
+gboolean
+e_web_view_gtkhtml_get_caret_mode (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_caret_mode(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_caret_mode (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_caret_mode (EWebViewGtkHTML *web_view,
+                           gboolean caret_mode)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_caret_mode()
+	 *     so we can get a "notify::caret-mode" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_caret_mode (GTK_HTML (web_view), caret_mode);
+
+	g_object_notify (G_OBJECT (web_view), "caret-mode");
+}
+
+GtkTargetList *
+e_web_view_gtkhtml_get_copy_target_list (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	return web_view->priv->copy_target_list;
+}
+
+gboolean
+e_web_view_gtkhtml_get_disable_printing (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return web_view->priv->disable_printing;
+}
+
+void
+e_web_view_gtkhtml_set_disable_printing (EWebViewGtkHTML *web_view,
+                                 gboolean disable_printing)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	web_view->priv->disable_printing = disable_printing;
+
+	g_object_notify (G_OBJECT (web_view), "disable-printing");
+}
+
+gboolean
+e_web_view_gtkhtml_get_disable_save_to_disk (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return web_view->priv->disable_save_to_disk;
+}
+
+void
+e_web_view_gtkhtml_set_disable_save_to_disk (EWebViewGtkHTML *web_view,
+                                     gboolean disable_save_to_disk)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	web_view->priv->disable_save_to_disk = disable_save_to_disk;
+
+	g_object_notify (G_OBJECT (web_view), "disable-save-to-disk");
+}
+
+gboolean
+e_web_view_gtkhtml_get_editable (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_editable(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_editable (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_editable (EWebViewGtkHTML *web_view,
+                         gboolean editable)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_editable()
+	 *     so we can get a "notify::editable" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_editable (GTK_HTML (web_view), editable);
+
+	g_object_notify (G_OBJECT (web_view), "editable");
+}
+
+gboolean
+e_web_view_gtkhtml_get_inline_spelling (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_inline_spelling(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_inline_spelling (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_inline_spelling (EWebViewGtkHTML *web_view,
+                                gboolean inline_spelling)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_inline_spelling()
+	 *     so we get a "notify::inline-spelling" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_inline_spelling (GTK_HTML (web_view), inline_spelling);
+
+	g_object_notify (G_OBJECT (web_view), "inline-spelling");
+}
+
+gboolean
+e_web_view_gtkhtml_get_magic_links (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_magic_links(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_magic_links (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_magic_links (EWebViewGtkHTML *web_view,
+                            gboolean magic_links)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_magic_links()
+	 *     so we can get a "notify::magic-links" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_magic_links (GTK_HTML (web_view), magic_links);
+
+	g_object_notify (G_OBJECT (web_view), "magic-links");
+}
+
+gboolean
+e_web_view_gtkhtml_get_magic_smileys (EWebViewGtkHTML *web_view)
+{
+	/* XXX This is just here to maintain symmetry
+	 *     with e_web_view_set_magic_smileys(). */
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_get_magic_smileys (GTK_HTML (web_view));
+}
+
+void
+e_web_view_gtkhtml_set_magic_smileys (EWebViewGtkHTML *web_view,
+                              gboolean magic_smileys)
+{
+	/* XXX GtkHTML does not utilize GObject properties as well
+	 *     as it could.  This just wraps gtk_html_set_magic_smileys()
+	 *     so we can get a "notify::magic-smileys" signal. */
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_set_magic_smileys (GTK_HTML (web_view), magic_smileys);
+
+	g_object_notify (G_OBJECT (web_view), "magic-smileys");
+}
+
+const gchar *
+e_web_view_gtkhtml_get_selected_uri (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	return web_view->priv->selected_uri;
+}
+
+void
+e_web_view_gtkhtml_set_selected_uri (EWebViewGtkHTML *web_view,
+                             const gchar *selected_uri)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_free (web_view->priv->selected_uri);
+	web_view->priv->selected_uri = g_strdup (selected_uri);
+
+	g_object_notify (G_OBJECT (web_view), "selected-uri");
+}
+
+GdkPixbufAnimation *
+e_web_view_gtkhtml_get_cursor_image (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	return web_view->priv->cursor_image;
+}
+
+void
+e_web_view_gtkhtml_set_cursor_image (EWebViewGtkHTML *web_view,
+                             GdkPixbufAnimation *image)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	if (image != NULL)
+		g_object_ref (image);
+
+	if (web_view->priv->cursor_image != NULL)
+		g_object_unref (web_view->priv->cursor_image);
+
+	web_view->priv->cursor_image = image;
+
+	g_object_notify (G_OBJECT (web_view), "cursor-image");
+}
+
+GtkAction *
+e_web_view_gtkhtml_get_open_proxy (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return web_view->priv->open_proxy;
+}
+
+void
+e_web_view_gtkhtml_set_open_proxy (EWebViewGtkHTML *web_view,
+                           GtkAction *open_proxy)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	if (open_proxy != NULL) {
+		g_return_if_fail (GTK_IS_ACTION (open_proxy));
+		g_object_ref (open_proxy);
+	}
+
+	if (web_view->priv->open_proxy != NULL)
+		g_object_unref (web_view->priv->open_proxy);
+
+	web_view->priv->open_proxy = open_proxy;
+
+	g_object_notify (G_OBJECT (web_view), "open-proxy");
+}
+
+GtkTargetList *
+e_web_view_gtkhtml_get_paste_target_list (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	return web_view->priv->paste_target_list;
+}
+
+GtkAction *
+e_web_view_gtkhtml_get_print_proxy (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return web_view->priv->print_proxy;
+}
+
+void
+e_web_view_gtkhtml_set_print_proxy (EWebViewGtkHTML *web_view,
+                            GtkAction *print_proxy)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	if (print_proxy != NULL) {
+		g_return_if_fail (GTK_IS_ACTION (print_proxy));
+		g_object_ref (print_proxy);
+	}
+
+	if (web_view->priv->print_proxy != NULL)
+		g_object_unref (web_view->priv->print_proxy);
+
+	web_view->priv->print_proxy = print_proxy;
+
+	g_object_notify (G_OBJECT (web_view), "print-proxy");
+}
+
+GtkAction *
+e_web_view_gtkhtml_get_save_as_proxy (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return web_view->priv->save_as_proxy;
+}
+
+void
+e_web_view_gtkhtml_set_save_as_proxy (EWebViewGtkHTML *web_view,
+                              GtkAction *save_as_proxy)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	if (save_as_proxy != NULL) {
+		g_return_if_fail (GTK_IS_ACTION (save_as_proxy));
+		g_object_ref (save_as_proxy);
+	}
+
+	if (web_view->priv->save_as_proxy != NULL)
+		g_object_unref (web_view->priv->save_as_proxy);
+
+	web_view->priv->save_as_proxy = save_as_proxy;
+
+	g_object_notify (G_OBJECT (web_view), "save-as-proxy");
+}
+
+GtkAction *
+e_web_view_gtkhtml_get_action (EWebViewGtkHTML *web_view,
+                       const gchar *action_name)
+{
+	GtkUIManager *ui_manager;
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+	g_return_val_if_fail (action_name != NULL, NULL);
+
+	ui_manager = e_web_view_gtkhtml_get_ui_manager (web_view);
+
+	return e_lookup_action (ui_manager, action_name);
+}
+
+GtkActionGroup *
+e_web_view_gtkhtml_get_action_group (EWebViewGtkHTML *web_view,
+                             const gchar *group_name)
+{
+	GtkUIManager *ui_manager;
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+	g_return_val_if_fail (group_name != NULL, NULL);
+
+	ui_manager = e_web_view_gtkhtml_get_ui_manager (web_view);
+
+	return e_lookup_action_group (ui_manager, group_name);
+}
+
+gchar *
+e_web_view_gtkhtml_extract_uri (EWebViewGtkHTML *web_view,
+                        GdkEventButton *event,
+                        GtkHTML *frame)
+{
+	EWebViewGtkHTMLClass *class;
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	if (frame == NULL)
+		frame = GTK_HTML (web_view);
+
+	class = E_WEB_VIEW_GTKHTML_GET_CLASS (web_view);
+	g_return_val_if_fail (class->extract_uri != NULL, NULL);
+
+	return class->extract_uri (web_view, event, frame);
+}
+
+void
+e_web_view_gtkhtml_copy_clipboard (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[COPY_CLIPBOARD], 0);
+}
+
+void
+e_web_view_gtkhtml_cut_clipboard (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[CUT_CLIPBOARD], 0);
+}
+
+gboolean
+e_web_view_gtkhtml_is_selection_active (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_command (GTK_HTML (web_view), "is-selection-active");
+}
+
+void
+e_web_view_gtkhtml_paste_clipboard (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[PASTE_CLIPBOARD], 0);
+}
+
+gboolean
+e_web_view_gtkhtml_scroll_forward (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_command (GTK_HTML (web_view), "scroll-forward");
+}
+
+gboolean
+e_web_view_gtkhtml_scroll_backward (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), FALSE);
+
+	return gtk_html_command (GTK_HTML (web_view), "scroll-backward");
+}
+
+void
+e_web_view_gtkhtml_select_all (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_command (GTK_HTML (web_view), "select-all");
+}
+
+void
+e_web_view_gtkhtml_unselect_all (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_command (GTK_HTML (web_view), "unselect-all");
+}
+
+void
+e_web_view_gtkhtml_zoom_100 (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_command (GTK_HTML (web_view), "zoom-reset");
+}
+
+void
+e_web_view_gtkhtml_zoom_in (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_command (GTK_HTML (web_view), "zoom-in");
+}
+
+void
+e_web_view_gtkhtml_zoom_out (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	gtk_html_command (GTK_HTML (web_view), "zoom-out");
+}
+
+GtkUIManager *
+e_web_view_gtkhtml_get_ui_manager (EWebViewGtkHTML *web_view)
+{
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	return web_view->priv->ui_manager;
+}
+
+GtkWidget *
+e_web_view_gtkhtml_get_popup_menu (EWebViewGtkHTML *web_view)
+{
+	GtkUIManager *ui_manager;
+	GtkWidget *menu;
+
+	g_return_val_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view), NULL);
+
+	ui_manager = e_web_view_gtkhtml_get_ui_manager (web_view);
+	menu = gtk_ui_manager_get_widget (ui_manager, "/context");
+	g_return_val_if_fail (GTK_IS_MENU (menu), NULL);
+
+	return menu;
+}
+
+void
+e_web_view_gtkhtml_show_popup_menu (EWebViewGtkHTML *web_view,
+                            GdkEventButton *event,
+                            GtkMenuPositionFunc func,
+                            gpointer user_data)
+{
+	GtkWidget *menu;
+
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	e_web_view_gtkhtml_update_actions (web_view);
+
+	menu = e_web_view_gtkhtml_get_popup_menu (web_view);
+
+	if (event != NULL)
+		gtk_menu_popup (
+			GTK_MENU (menu), NULL, NULL, func,
+			user_data, event->button, event->time);
+	else
+		gtk_menu_popup (
+			GTK_MENU (menu), NULL, NULL, func,
+			user_data, 0, gtk_get_current_event_time ());
+}
+
+void
+e_web_view_gtkhtml_status_message (EWebViewGtkHTML *web_view,
+                           const gchar *status_message)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[STATUS_MESSAGE], 0, status_message);
+}
+
+void
+e_web_view_gtkhtml_stop_loading (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[STOP_LOADING], 0);
+}
+
+void
+e_web_view_gtkhtml_update_actions (EWebViewGtkHTML *web_view)
+{
+	g_return_if_fail (E_IS_WEB_VIEW_GTKHTML (web_view));
+
+	g_signal_emit (web_view, signals[UPDATE_ACTIONS], 0);
+}
diff --git a/widgets/misc/e-web-view-gtkhtml.h b/widgets/misc/e-web-view-gtkhtml.h
new file mode 100644
index 0000000..281a9f9
--- /dev/null
+++ b/widgets/misc/e-web-view-gtkhtml.h
@@ -0,0 +1,173 @@
+/*
+ * e-web-view-gtkhtml.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/>
+ *
+ */
+
+/* This is intended to serve as a common base class for all HTML viewing
+ * needs in Evolution.  Currently based on GtkHTML, the idea is to wrap
+ * the GtkHTML API enough that we no longer have to make direct calls to
+ * it.  This should help smooth the transition to WebKit/GTK+.
+ *
+ * This class handles basic tasks like mouse hovers over links, clicked
+ * links, and servicing URI requests asynchronously via GIO. */
+
+#ifndef E_WEB_VIEW_GTKHTML_H
+#define E_WEB_VIEW_GTKHTML_H
+
+#include <gtkhtml/gtkhtml.h>
+
+/* Standard GObject macros */
+#define E_TYPE_WEB_VIEW_GTKHTML \
+	(e_web_view_gtkhtml_get_type ())
+#define E_WEB_VIEW_GTKHTML(obj) \
+	(G_TYPE_CHECK_INSTANCE_CAST \
+	((obj), E_TYPE_WEB_VIEW_GTKHTML, EWebViewGtkHTML))
+#define E_WEB_VIEW_GTKHTML_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_CAST \
+	((cls), E_TYPE_WEB_VIEW_GTKHTML, EWebViewGtkHTMLClass))
+#define E_IS_WEB_VIEW_GTKHTML(obj) \
+	(G_TYPE_CHECK_INSTANCE_TYPE \
+	((obj), E_TYPE_WEB_VIEW_GTKHTML))
+#define E_IS_WEB_VIEW_GTKHTML_CLASS(cls) \
+	(G_TYPE_CHECK_CLASS_TYPE \
+	((cls), E_TYPE_WEB_VIEW_GTKHTML))
+#define E_WEB_VIEW_GTKHTML_GET_CLASS(obj) \
+	(G_TYPE_INSTANCE_GET_CLASS \
+	((obj), E_TYPE_WEB_VIEW_GTKHTML, EWebViewGtkHTMLClass))
+
+G_BEGIN_DECLS
+
+typedef struct _EWebViewGtkHTML EWebViewGtkHTML;
+typedef struct _EWebViewGtkHTMLClass EWebViewGtkHTMLClass;
+typedef struct _EWebViewGtkHTMLPrivate EWebViewGtkHTMLPrivate;
+
+struct _EWebViewGtkHTML {
+	GtkHTML parent;
+	EWebViewGtkHTMLPrivate *priv;
+};
+
+struct _EWebViewGtkHTMLClass {
+	GtkHTMLClass parent_class;
+
+	/* Methods */
+	gchar *		(*extract_uri)		(EWebViewGtkHTML *web_view,
+						 GdkEventButton *event,
+						 GtkHTML *frame);
+	void		(*hovering_over_link)	(EWebViewGtkHTML *web_view,
+						 const gchar *title,
+						 const gchar *uri);
+	void		(*link_clicked)		(EWebViewGtkHTML *web_view,
+						 const gchar *uri);
+	void		(*load_string)		(EWebViewGtkHTML *web_view,
+						 const gchar *load_string);
+
+	/* Signals */
+	void		(*copy_clipboard)	(EWebViewGtkHTML *web_view);
+	void		(*cut_clipboard)	(EWebViewGtkHTML *web_view);
+	void		(*paste_clipboard)	(EWebViewGtkHTML *web_view);
+	gboolean	(*popup_event)		(EWebViewGtkHTML *web_view,
+						 GdkEventButton *event,
+						 const gchar *uri);
+	void		(*status_message)	(EWebViewGtkHTML *web_view,
+						 const gchar *status_message);
+	void		(*stop_loading)		(EWebViewGtkHTML *web_view);
+	void		(*update_actions)	(EWebViewGtkHTML *web_view);
+	gboolean	(*process_mailto)	(EWebViewGtkHTML *web_view,
+						 const gchar *mailto_uri);
+};
+
+GType		e_web_view_gtkhtml_get_type		(void);
+GtkWidget *	e_web_view_gtkhtml_new			(void);
+void		e_web_view_gtkhtml_clear		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_load_string		(EWebViewGtkHTML *web_view,
+						 	 const gchar *string);
+gboolean	e_web_view_gtkhtml_get_animate		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_animate		(EWebViewGtkHTML *web_view,
+						 	 gboolean animate);
+gboolean	e_web_view_gtkhtml_get_caret_mode	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_caret_mode	(EWebViewGtkHTML *web_view,
+						 	 gboolean caret_mode);
+GtkTargetList *	e_web_view_gtkhtml_get_copy_target_list	(EWebViewGtkHTML *web_view);
+gboolean	e_web_view_gtkhtml_get_disable_printing	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_disable_printing	(EWebViewGtkHTML *web_view,
+						 	 gboolean disable_printing);
+gboolean	e_web_view_gtkhtml_get_disable_save_to_disk
+							(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_disable_save_to_disk
+							(EWebViewGtkHTML *web_view,
+						 	 gboolean disable_save_to_disk);
+gboolean	e_web_view_gtkhtml_get_editable		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_editable		(EWebViewGtkHTML *web_view,
+						 	 gboolean editable);
+gboolean	e_web_view_gtkhtml_get_inline_spelling	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_inline_spelling	(EWebViewGtkHTML *web_view,
+							 gboolean inline_spelling);
+gboolean	e_web_view_gtkhtml_get_magic_links	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_magic_links	(EWebViewGtkHTML *web_view,
+							 gboolean magic_links);
+gboolean	e_web_view_gtkhtml_get_magic_smileys	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_magic_smileys	(EWebViewGtkHTML *web_view,
+							 gboolean magic_smileys);
+const gchar *	e_web_view_gtkhtml_get_selected_uri	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_selected_uri	(EWebViewGtkHTML *web_view,
+							 const gchar *selected_uri);
+GdkPixbufAnimation *
+		e_web_view_gtkhtml_get_cursor_image	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_cursor_image	(EWebViewGtkHTML *web_view,
+							 GdkPixbufAnimation *animation);
+GtkAction *	e_web_view_gtkhtml_get_open_proxy	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_open_proxy	(EWebViewGtkHTML *web_view,
+							 GtkAction *open_proxy);
+GtkTargetList *	e_web_view_gtkhtml_get_paste_target_list
+							(EWebViewGtkHTML *web_view);
+GtkAction *	e_web_view_gtkhtml_get_print_proxy	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_print_proxy	(EWebViewGtkHTML *web_view,
+						 	 GtkAction *print_proxy);
+GtkAction *	e_web_view_gtkhtml_get_save_as_proxy	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_set_save_as_proxy	(EWebViewGtkHTML *web_view,
+						 	 GtkAction *save_as_proxy);
+GtkAction *	e_web_view_gtkhtml_get_action		(EWebViewGtkHTML *web_view,
+							 const gchar *action_name);
+GtkActionGroup *e_web_view_gtkhtml_get_action_group	(EWebViewGtkHTML *web_view,
+							 const gchar *group_name);
+gchar *		e_web_view_gtkhtml_extract_uri		(EWebViewGtkHTML *web_view,
+							 GdkEventButton *event,
+							 GtkHTML *frame);
+void		e_web_view_gtkhtml_copy_clipboard	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_cut_clipboard	(EWebViewGtkHTML *web_view);
+gboolean	e_web_view_gtkhtml_is_selection_active	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_paste_clipboard	(EWebViewGtkHTML *web_view);
+gboolean	e_web_view_gtkhtml_scroll_forward	(EWebViewGtkHTML *web_view);
+gboolean	e_web_view_gtkhtml_scroll_backward	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_select_all		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_unselect_all		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_zoom_100		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_zoom_in		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_zoom_out		(EWebViewGtkHTML *web_view);
+GtkUIManager *	e_web_view_gtkhtml_get_ui_manager	(EWebViewGtkHTML *web_view);
+GtkWidget *	e_web_view_gtkhtml_get_popup_menu	(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_show_popup_menu	(EWebViewGtkHTML *web_view,
+							 GdkEventButton *event,
+							 GtkMenuPositionFunc func,
+							 gpointer user_data);
+void		e_web_view_gtkhtml_status_message	(EWebViewGtkHTML *web_view,
+						 	const gchar *status_message);
+void		e_web_view_gtkhtml_stop_loading		(EWebViewGtkHTML *web_view);
+void		e_web_view_gtkhtml_update_actions	(EWebViewGtkHTML *web_view);
+
+G_END_DECLS
+
+#endif /* E_WEB_VIEW_GTKHTML_H */