/*
 * e-mail-display.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-mail-display.h"

#include <config.h>
#include <string.h>
#include <glib/gi18n.h>

#include "e-util/e-util.h"
#include "e-util/e-plugin-ui.h"
#include "mail/em-composer-utils.h"
#include "mail/em-utils.h"

#define E_MAIL_DISPLAY_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), E_TYPE_MAIL_DISPLAY, EMailDisplayPrivate))

struct _EMailDisplayPrivate {
	EMFormatHTML *formatter;
	GtkUIManager *ui_manager;
	gchar *selected_uri;
};

enum {
	PROP_0,
	PROP_ANIMATE,
	PROP_CARET_MODE,
	PROP_FORMATTER,
	PROP_SELECTED_URI
};

enum {
	POPUP_EVENT,
	STATUS_MESSAGE,
	LAST_SIGNAL
};

static gpointer parent_class;
static guint signals[LAST_SIGNAL];

static const gchar *ui =
"<ui>"
"  <popup name='context'>"
"    <menuitem action='http-open'/>"
"    <menuitem action='send-message'/>"
"    <menuitem action='uri-copy'/>"
"    <menuitem action='add-to-address-book'/>"
"    <menuitem action='mailto-copy'/>"
"    <menu action='search-folder-menu'>"
"      <menuitem action='search-folder-sender'/>"
"      <menuitem action='search-folder-recipient'/>"
"    </menu>"
"  </popup>"
"</ui>";

static void
action_add_to_address_book_cb (GtkAction *action,
                               EMailDisplay *display)
{
	CamelURL *curl;
	const gchar *uri;
	gpointer parent;

	parent = gtk_widget_get_toplevel (GTK_WIDGET (display));
	parent = GTK_WIDGET_TOPLEVEL (parent) ? parent : NULL;

	uri = e_mail_display_get_selected_uri (display);
	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);

	if (curl->path != NULL && *curl->path != '\0')
		em_utils_add_address (parent, curl->path);

	camel_url_free (curl);
}

static void
action_http_open_cb (GtkAction *action,
                     EMailDisplay *display)
{
	const gchar *uri;
	gpointer parent;

	parent = gtk_widget_get_toplevel (GTK_WIDGET (display));
	parent = GTK_WIDGET_TOPLEVEL (parent) ? parent : NULL;

	uri = e_mail_display_get_selected_uri (display);
	g_return_if_fail (uri != NULL);

	e_show_uri (parent, uri);
}

static void
action_mailto_copy_cb (GtkAction *action,
                       EMailDisplay *display)
{
	CamelURL *curl;
	CamelInternetAddress *inet_addr;
	GtkClipboard *clipboard;
	const gchar *uri;
	gchar *text;

	clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
	uri = e_mail_display_get_selected_uri (display);
	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_encode (CAMEL_ADDRESS (inet_addr));
	if (text == NULL || *text == '\0')
		text = g_strdup (uri + strlen ("mailto:"));

	camel_object_unref (inet_addr);
	camel_url_free (curl);

	gtk_clipboard_set_text (clipboard, text, -1);
	gtk_clipboard_store (clipboard);

	g_free (text);
}

static void
action_send_message_cb (GtkAction *action,
                        EMailDisplay *display)
{
	const gchar *uri;

	uri = e_mail_display_get_selected_uri (display);
	g_return_if_fail (uri != NULL);

	em_utils_compose_new_message_with_mailto (uri, NULL);
}

static void
action_uri_copy_cb (GtkAction *action,
                    EMailDisplay *display)
{
	GtkClipboard *clipboard;
	const gchar *uri;

	clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
	uri = e_mail_display_get_selected_uri (display);
	g_return_if_fail (uri != NULL);

	gtk_clipboard_set_text (clipboard, uri, -1);
	gtk_clipboard_store (clipboard);
}

static GtkActionEntry uri_entries[] = {

	{ "uri-copy",
	  GTK_STOCK_COPY,
	  N_("_Copy Link Location"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  G_CALLBACK (action_uri_copy_cb) },
};

static GtkActionEntry http_entries[] = {

	{ "http-open",
	  "emblem-web",
	  N_("_Open Link in Browser"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  G_CALLBACK (action_http_open_cb) },
};

static GtkActionEntry mailto_entries[] = {

	{ "add-to-address-book",
	  "contact-new",
	  N_("_Add to Address Book"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  G_CALLBACK (action_add_to_address_book_cb) },

	{ "mailto-copy",
	  GTK_STOCK_COPY,
	  N_("_Copy Email Address"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  G_CALLBACK (action_mailto_copy_cb) },

	{ "search-folder-recipient",
	  NULL,
	  N_("_To This Address"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  NULL   /* Handled by EMailReader */ },

	{ "search-folder-sender",
	  NULL,
	  N_("_From This Address"),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  NULL   /* Handled by EMailReader */ },

	{ "send-message",
	  "mail-message-new",
	  N_("_Send New Message To..."),
	  NULL,
	  NULL,  /* XXX Add a tooltip! */
	  G_CALLBACK (action_send_message_cb) },

	/*** Menus ***/

	{ "search-folder-menu",
	  "folder-saved-search",
	  N_("Create Search _Folder"),
	  NULL,
	  NULL,
	  NULL }
};

static gboolean
mail_display_emit_popup_event (EMailDisplay *display,
                               GdkEventButton *event,
                               const gchar *uri,
                               EMFormatPURI *puri)
{
	CamelMimePart *mime_part;
	gboolean stop_handlers = FALSE;

	mime_part = (puri != NULL) ? puri->part : NULL;

	g_signal_emit (
		display, signals[POPUP_EVENT], 0,
		event, uri, mime_part, &stop_handlers);

	return stop_handlers;
}

static void
mail_display_emit_status_message (EMailDisplay *display,
                                  const gchar *status_message)
{
	g_signal_emit (display, signals[STATUS_MESSAGE], 0, status_message);
}

static void
mail_display_get_uri_puri (EMailDisplay *display,
                           GdkEventButton *event,
                           GtkHTML *html,
                           gchar **uri,
                           EMFormatPURI **puri)
{
	EMFormat *formatter;
	gchar *text_uri;
	gchar *image_uri;
	gboolean is_cid;

	formatter = EM_FORMAT (display->priv->formatter);

	if (event != NULL) {
		text_uri = gtk_html_get_url_at (html, event->x, event->y);
		image_uri = gtk_html_get_image_src_at (html, event->x, event->y);
	} else {
		text_uri = gtk_html_get_cursor_url (html);
		image_uri = gtk_html_get_cursor_image_src (html);
	}

	is_cid = (image_uri != NULL) &&
		(g_ascii_strncasecmp (image_uri, "cid:", 4) == 0);

	if (image_uri != NULL) {
		if (strstr (image_uri, "://") == NULL && !is_cid) {
			gchar *temp;

			temp = g_strconcat ("file://", image_uri, NULL);
			g_free (image_uri);
			image_uri = temp;
		}
	}

	if (puri != NULL) {
		if (text_uri != NULL)
			*puri = em_format_find_puri (formatter, text_uri);

		if (*puri == NULL && image_uri != NULL)
			*puri = em_format_find_puri (formatter, image_uri);
	}

	if (uri != NULL) {
		*uri = NULL;
		if (is_cid) {
			if (text_uri != NULL)
				*uri = g_strdup_printf (
					"%s\n%s", text_uri, image_uri);
			else {
				*uri = image_uri;
				image_uri = NULL;
			}
		} else {
			*uri = text_uri;
			text_uri = NULL;
		}
	}

	g_free (text_uri);
	g_free (image_uri);
}

static gboolean
mail_display_button_press_event_cb (EMailDisplay *display,
                                    GdkEventButton *event,
                                    GtkHTML *html)
{
	EMFormatPURI *puri = NULL;
	gboolean finished = TRUE;
	gchar *uri = NULL;

	/* The GtkHTML object may be the EMailDisplay itself
	 * or an inner iframe. */

	if (event->button != 3)
		return FALSE;

	mail_display_get_uri_puri (display, event, html, &uri, &puri);

	if (uri == NULL || g_str_has_prefix (uri, "##")) {
		g_free (uri);
		return FALSE;
	}

	finished = mail_display_emit_popup_event (display, event, uri, puri);

	g_free (uri);

	return finished;
}

static void
mail_display_update_formatter_colors (EMailDisplay *display)
{
	EMFormatHTMLColorType type;
	EMFormatHTML *formatter;
	GdkColor *color;
	GtkStyle *style;
	gint state;

	state = GTK_WIDGET_STATE (display);
	formatter = display->priv->formatter;

	style = gtk_widget_get_style (GTK_WIDGET (display));
	if (style == NULL)
		return;

	g_object_freeze_notify (G_OBJECT (formatter));

	color = &style->bg[state];
	type = EM_FORMAT_HTML_COLOR_BODY;
	em_format_html_set_color (formatter, type, color);

	color = &style->base[GTK_STATE_NORMAL];
	type = EM_FORMAT_HTML_COLOR_CONTENT;
	em_format_html_set_color (formatter, type, color);

	color = &style->dark[state];
	type = EM_FORMAT_HTML_COLOR_FRAME;
	em_format_html_set_color (formatter, type, color);

	color = &style->fg[state];
	type = EM_FORMAT_HTML_COLOR_HEADER;
	em_format_html_set_color (formatter, type, color);

	color = &style->text[state];
	type = EM_FORMAT_HTML_COLOR_TEXT;
	em_format_html_set_color (formatter, type, color);

	g_object_thaw_notify (G_OBJECT (formatter));
}

static void
mail_display_set_property (GObject *object,
                           guint property_id,
                           const GValue *value,
                           GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_ANIMATE:
			e_mail_display_set_animate (
				E_MAIL_DISPLAY (object),
				g_value_get_boolean (value));
			return;

		case PROP_CARET_MODE:
			e_mail_display_set_caret_mode (
				E_MAIL_DISPLAY (object),
				g_value_get_boolean (value));
			return;

		case PROP_FORMATTER:
			e_mail_display_set_formatter (
				E_MAIL_DISPLAY (object),
				g_value_get_object (value));
			return;

		case PROP_SELECTED_URI:
			e_mail_display_set_selected_uri (
				E_MAIL_DISPLAY (object),
				g_value_get_string (value));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_display_get_property (GObject *object,
                           guint property_id,
                           GValue *value,
                           GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_ANIMATE:
			g_value_set_boolean (
				value, e_mail_display_get_animate (
				E_MAIL_DISPLAY (object)));
			return;

		case PROP_CARET_MODE:
			g_value_set_boolean (
				value, e_mail_display_get_caret_mode (
				E_MAIL_DISPLAY (object)));
			return;

		case PROP_FORMATTER:
			g_value_set_object (
				value, e_mail_display_get_formatter (
				E_MAIL_DISPLAY (object)));
			return;

		case PROP_SELECTED_URI:
			g_value_set_string (
				value, e_mail_display_get_selected_uri (
				E_MAIL_DISPLAY (object)));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_display_dispose (GObject *object)
{
	EMailDisplayPrivate *priv;

	priv = E_MAIL_DISPLAY_GET_PRIVATE (object);

	if (priv->formatter) {
		g_object_unref (priv->formatter);
		priv->formatter = NULL;
	}

	if (priv->ui_manager) {
		g_object_unref (priv->ui_manager);
		priv->ui_manager = NULL;
	}

	/* Chain up to parent's dispose() method. */
	G_OBJECT_CLASS (parent_class)->dispose (object);
}

static void
mail_display_realize (GtkWidget *widget)
{
	/* Chain up to parent's realize() method. */
	GTK_WIDGET_CLASS (parent_class)->realize (widget);

	mail_display_update_formatter_colors (E_MAIL_DISPLAY (widget));
}

static void
mail_display_style_set (GtkWidget *widget,
                        GtkStyle *previous_style)
{
	EMailDisplayPrivate *priv;

	priv = E_MAIL_DISPLAY_GET_PRIVATE (widget);

	/* Chain up to parent's style_set() method. */
	GTK_WIDGET_CLASS (parent_class)->style_set (widget, previous_style);

	mail_display_update_formatter_colors (E_MAIL_DISPLAY (widget));
	em_format_redraw (EM_FORMAT (priv->formatter));
}

static gboolean
mail_display_button_press_event (GtkWidget *widget,
                                 GdkEventButton *event)
{
	EMailDisplay *display = E_MAIL_DISPLAY (widget);
	GtkHTML *html = GTK_HTML (widget);

	if (mail_display_button_press_event_cb (display, event, html))
		return TRUE;

	/* Chain up to parent's button_press_event() method. */
	return GTK_WIDGET_CLASS (parent_class)->
		button_press_event (widget, event);
}

static gboolean
mail_display_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
mail_display_link_clicked (GtkHTML *html,
                           const gchar *uri)
{
	EMailDisplayPrivate *priv;

	priv = E_MAIL_DISPLAY_GET_PRIVATE (html);
	g_return_if_fail (priv->formatter != NULL);

	if (g_str_has_prefix (uri, "##")) {
		guint32 flags;

		flags = priv->formatter->header_wrap_flags;

		if (strcmp (uri, "##TO##") == 0) {
			if (!(flags & EM_FORMAT_HTML_HEADER_TO))
				flags |= EM_FORMAT_HTML_HEADER_TO;
			else
				flags &= ~EM_FORMAT_HTML_HEADER_TO;
		} else if (strcmp (uri, "##CC##") == 0) {
			if (!(flags & EM_FORMAT_HTML_HEADER_CC))
				flags |= EM_FORMAT_HTML_HEADER_CC;
			else
				flags |= EM_FORMAT_HTML_HEADER_CC;
		} else if (strcmp (uri, "##BCC##") == 0) {
			if (!(flags & EM_FORMAT_HTML_HEADER_BCC))
				flags |= EM_FORMAT_HTML_HEADER_BCC;
			else
				flags |= EM_FORMAT_HTML_HEADER_BCC;
		}

		priv->formatter->header_wrap_flags = flags;
		em_format_redraw (EM_FORMAT (priv->formatter));

	} else if (*uri == '#')
		gtk_html_jump_to_anchor (html, uri + 1);

	else if (g_ascii_strncasecmp (uri, "thismessage:", 12) == 0)
		/* ignore */ ;

	else if (g_ascii_strncasecmp (uri, "cid:", 4) == 0)
		/* ignore */ ;

	else {
		gpointer parent;

		parent = gtk_widget_get_toplevel (GTK_WIDGET (html));
		parent = GTK_WIDGET_TOPLEVEL (parent) ? parent : NULL;

		e_show_uri (parent, uri);
	}
}

static void
mail_display_on_url (GtkHTML *html,
                     const gchar *uri)
{
	EMailDisplay *display;
	CamelInternetAddress *address;
	CamelURL *curl;
	const gchar *format = NULL;
	gchar *message = NULL;
	gchar *who;

	display = E_MAIL_DISPLAY (html);

	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;

	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));
	camel_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:
	mail_display_emit_status_message (display, message);

	g_free (message);
}

static void
mail_display_iframe_created (GtkHTML *html,
                             GtkHTML *iframe)
{
	g_signal_connect_swapped (
		iframe, "button-press-event",
		G_CALLBACK (mail_display_button_press_event_cb), html);
}

static gboolean
mail_display_popup_event (EMailDisplay *display,
                          GdkEventButton *event,
                          const gchar *uri,
                          EMFormatPURI *puri)
{
	e_mail_display_set_selected_uri (display, uri);
	e_mail_display_show_popup_menu (display, event, NULL, NULL);

	return TRUE;
}

static void
mail_display_class_init (EMailDisplayClass *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 (EMailDisplayPrivate));

	object_class = G_OBJECT_CLASS (class);
	object_class->set_property = mail_display_set_property;
	object_class->get_property = mail_display_get_property;
	object_class->dispose = mail_display_dispose;

	widget_class = GTK_WIDGET_CLASS (class);
	widget_class->realize = mail_display_realize;
	widget_class->style_set = mail_display_style_set;
	widget_class->button_press_event = mail_display_button_press_event;
	widget_class->scroll_event = mail_display_scroll_event;

	html_class = GTK_HTML_CLASS (class);
	html_class->link_clicked = mail_display_link_clicked;
	html_class->on_url = mail_display_on_url;
	html_class->iframe_created = mail_display_iframe_created;

	class->popup_event = mail_display_popup_event;

	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));

	g_object_class_install_property (
		object_class,
		PROP_FORMATTER,
		g_param_spec_object (
			"formatter",
			"HTML Formatter",
			NULL,
			EM_TYPE_FORMAT_HTML,
			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));

	signals[POPUP_EVENT] = g_signal_new (
		"popup-event",
		G_TYPE_FROM_CLASS (class),
		G_SIGNAL_RUN_LAST,
		G_STRUCT_OFFSET (EMailDisplayClass, popup_event),
		g_signal_accumulator_true_handled, NULL,
		e_marshal_BOOLEAN__BOXED_POINTER_POINTER,
		G_TYPE_BOOLEAN, 3,
		GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE,
		G_TYPE_POINTER,
		G_TYPE_POINTER);

	signals[STATUS_MESSAGE] = g_signal_new (
		"status-message",
		G_TYPE_FROM_CLASS (class),
		G_SIGNAL_RUN_FIRST,
		G_STRUCT_OFFSET (EMailDisplayClass, status_message),
		NULL, NULL,
		g_cclosure_marshal_VOID__STRING,
		G_TYPE_NONE, 1,
		G_TYPE_STRING);
}

static void
mail_display_init (EMailDisplay *display)
{
	GtkUIManager *ui_manager;
	GtkActionGroup *action_group;
	const gchar *id;
	GError *error = NULL;

	display->priv = E_MAIL_DISPLAY_GET_PRIVATE (display);

	ui_manager = gtk_ui_manager_new ();
	display->priv->ui_manager = ui_manager;

	action_group = e_mail_display_add_action_group (display, "uri");

	gtk_action_group_add_actions (
		action_group, uri_entries,
		G_N_ELEMENTS (uri_entries), display);

	action_group = e_mail_display_add_action_group (display, "http");

	gtk_action_group_add_actions (
		action_group, http_entries,
		G_N_ELEMENTS (http_entries), display);

	action_group = e_mail_display_add_action_group (display, "mailto");

	gtk_action_group_add_actions (
		action_group, mailto_entries,
		G_N_ELEMENTS (mailto_entries), display);

	/* 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.mail.display";
	e_plugin_ui_register_manager (ui_manager, id, display);
	e_plugin_ui_enable_manager (ui_manager, id);
}

GType
e_mail_display_get_type (void)
{
	static GType type = 0;

	if (G_UNLIKELY (type == 0)) {
		static const GTypeInfo type_info = {
			sizeof (EMailDisplayClass),
			(GBaseInitFunc) NULL,
			(GBaseFinalizeFunc) NULL,
			(GClassInitFunc) mail_display_class_init,
			(GClassFinalizeFunc) NULL,
			NULL,  /* class_data */
			sizeof (EMailDisplay),
			0,     /* n_preallocs */
			(GInstanceInitFunc) mail_display_init,
			NULL   /* value_table */
		};

		type = g_type_register_static (
			GTK_TYPE_HTML, "EMailDisplay", &type_info, 0);
	}

	return type;
}

gboolean
e_mail_display_get_animate (EMailDisplay *display)
{
	/* XXX This is just here to maintain symmetry
	 *     with e_mail_display_set_animate(). */

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), FALSE);

	return gtk_html_get_animate (GTK_HTML (display));
}

void
e_mail_display_set_animate (EMailDisplay *display,
                            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_MAIL_DISPLAY (display));

	gtk_html_set_animate (GTK_HTML (display), animate);

	g_object_notify (G_OBJECT (display), "animate");
}

gboolean
e_mail_display_get_caret_mode (EMailDisplay *display)
{
	/* XXX This is just here to maintain symmetry
	 *     with e_mail_display_set_caret_mode(). */

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), FALSE);

	return gtk_html_get_caret_mode (GTK_HTML (display));
}

void
e_mail_display_set_caret_mode (EMailDisplay *display,
                               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_MAIL_DISPLAY (display));

	gtk_html_set_caret_mode (GTK_HTML (display), caret_mode);

	g_object_notify (G_OBJECT (display), "caret-mode");
}

EMFormatHTML *
e_mail_display_get_formatter (EMailDisplay *display)
{
	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);

	return display->priv->formatter;
}

void
e_mail_display_set_formatter (EMailDisplay *display,
                              EMFormatHTML *formatter)
{
	g_return_if_fail (E_IS_MAIL_DISPLAY (display));
	g_return_if_fail (EM_IS_FORMAT_HTML (formatter));

	if (display->priv->formatter != NULL)
		g_object_unref (display->priv->formatter);

	display->priv->formatter = g_object_ref (formatter);

	g_object_notify (G_OBJECT (display), "formatter");
}

const gchar *
e_mail_display_get_selected_uri (EMailDisplay *display)
{
	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);

	return display->priv->selected_uri;
}

void
e_mail_display_set_selected_uri (EMailDisplay *display,
                                 const gchar *selected_uri)
{
	g_return_if_fail (E_IS_MAIL_DISPLAY (display));

	g_free (display->priv->selected_uri);
	display->priv->selected_uri = g_strdup (selected_uri);

	g_object_notify (G_OBJECT (display), "selected-uri");
}

GtkAction *
e_mail_display_get_action (EMailDisplay *display,
                           const gchar *action_name)
{
	GtkUIManager *ui_manager;

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);
	g_return_val_if_fail (action_name != NULL, NULL);

	ui_manager = e_mail_display_get_ui_manager (display);

	return e_lookup_action (ui_manager, action_name);
}

GtkActionGroup *
e_mail_display_add_action_group (EMailDisplay *display,
                                 const gchar *group_name)
{
	GtkActionGroup *action_group;
	GtkUIManager *ui_manager;
	const gchar *domain;

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);
	g_return_val_if_fail (group_name != NULL, NULL);

	ui_manager = e_mail_display_get_ui_manager (display);
	domain = GETTEXT_PACKAGE;

	action_group = gtk_action_group_new (group_name);
	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);

	return action_group;
}

GtkActionGroup *
e_mail_display_get_action_group (EMailDisplay *display,
                                 const gchar *group_name)
{
	GtkUIManager *ui_manager;

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);
	g_return_val_if_fail (group_name != NULL, NULL);

	ui_manager = e_mail_display_get_ui_manager (display);

	return e_lookup_action_group (ui_manager, group_name);
}

GtkWidget *
e_mail_display_get_popup_menu (EMailDisplay *display)
{
	GtkUIManager *ui_manager;
	GtkWidget *menu;

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);

	ui_manager = e_mail_display_get_ui_manager (display);
	menu = gtk_ui_manager_get_widget (ui_manager, "/context");
	g_return_val_if_fail (GTK_IS_MENU (menu), NULL);

	return menu;
}

GtkUIManager *
e_mail_display_get_ui_manager (EMailDisplay *display)
{
	EMailDisplayPrivate *priv;

	g_return_val_if_fail (E_IS_MAIL_DISPLAY (display), NULL);

	priv = E_MAIL_DISPLAY_GET_PRIVATE (display);

	return priv->ui_manager;
}

void
e_mail_display_show_popup_menu (EMailDisplay *display,
                                GdkEventButton *event,
                                GtkMenuPositionFunc func,
                                gpointer user_data)
{
	GtkWidget *menu;

	g_return_if_fail (E_IS_MAIL_DISPLAY (display));

	e_mail_display_update_actions (display);

	menu = e_mail_display_get_popup_menu (display);

	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_mail_display_update_actions (EMailDisplay *display)
{
	CamelURL *curl;
	GtkActionGroup *action_group;
	gboolean scheme_is_http;
	gboolean scheme_is_mailto;
	gboolean uri_is_valid;
	gboolean visible;
	const gchar *uri;

	g_return_if_fail (E_IS_MAIL_DISPLAY (display));

	uri = e_mail_display_get_selected_uri (display);
	g_return_if_fail (uri != NULL);

	/* Parse the URI early so we know if the actions will work. */
	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. */
	visible = !scheme_is_mailto;
	action_group = e_mail_display_get_action_group (display, "uri");
	gtk_action_group_set_visible (action_group, visible);

	visible = uri_is_valid && scheme_is_http;
	action_group = e_mail_display_get_action_group (display, "http");
	gtk_action_group_set_visible (action_group, visible);

	visible = uri_is_valid && scheme_is_mailto;
	action_group = e_mail_display_get_action_group (display, "mailto");
	gtk_action_group_set_visible (action_group, visible);
}