evolution/mail/em-format-html-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/>
 *
 *
 * Authors:
 *		Michael Zucchi <notzed@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>

#include <gtk/gtk.h>
#include <glib/gstdio.h>
#include <gdk/gdkkeysyms.h>

#ifdef G_OS_WIN32
/* Work around 'DATADIR' and 'interface' lossage in <windows.h> */
#define DATADIR crap_DATADIR
#include <windows.h>
#undef DATADIR
#undef interface
#endif

#include <glib/gi18n.h>

#include <e-util/e-util.h>
#include <e-util/e-util-private.h>

#include "e-util/e-datetime-format.h"
#include <e-util/e-dialog-utils.h>
#include <e-util/e-icon-factory.h>

#include <shell/e-shell.h>
#include <shell/e-shell-utils.h>

#include <libedataserver/e-flag.h>

#if defined (HAVE_NSS) && defined (ENABLE_SMIME)
#include "certificate-viewer.h"
#include "e-cert-db.h"
#endif

#include "e-mail-display.h"
#include "e-mail-attachment-bar.h"
#include "em-format-html-display.h"
#include "em-utils.h"
#include "widgets/misc/e-attachment.h"
#include "widgets/misc/e-attachment-button.h"
#include "widgets/misc/e-attachment-view.h"
#include "shell/e-shell.h"
#include "shell/e-shell-window.h"

#define EM_FORMAT_HTML_DISPLAY_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), EM_TYPE_FORMAT_HTML_DISPLAY, EMFormatHTMLDisplayPrivate))

#define d(x)

#define EM_FORMAT_HTML_DISPLAY_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), EM_TYPE_FORMAT_HTML_DISPLAY, EMFormatHTMLDisplayPrivate))

struct _EMFormatHTMLDisplayPrivate {

        EAttachmentView *last_view;

};

/* TODO: move the dialogue elsehwere */
/* FIXME: also in em-format-html.c */
static const struct {
	const gchar *icon, *shortdesc, *description;
} smime_sign_table[5] = {
	{ "stock_signature-bad", N_("Unsigned"), N_("This message is not signed. There is no guarantee that this message is authentic.") },
	{ "stock_signature-ok", N_("Valid signature"), N_("This message is signed and is valid meaning that it is very likely that this message is authentic.") },
	{ "stock_signature-bad", N_("Invalid signature"), N_("The signature of this message cannot be verified, it may have been altered in transit.") },
	{ "stock_signature", N_("Valid signature, but cannot verify sender"), N_("This message is signed with a valid signature, but the sender of the message cannot be verified.") },
	{ "stock_signature-bad", N_("Signature exists, but need public key"), N_("This message is signed with a signature, but there is no corresponding public key.") },

};

static const struct {
	const gchar *icon, *shortdesc, *description;
} smime_encrypt_table[4] = {
	{ "stock_lock-broken", N_("Unencrypted"), N_("This message is not encrypted. Its content may be viewed in transit across the Internet.") },
	{ "stock_lock-ok", N_("Encrypted, weak"), N_("This message is encrypted, but with a weak encryption algorithm. It would be difficult, but not impossible for an outsider to view the content of this message in a practical amount of time.") },
	{ "stock_lock-ok", N_("Encrypted"), N_("This message is encrypted.  It would be difficult for an outsider to view the content of this message.") },
	{ "stock_lock-ok", N_("Encrypted, strong"), N_("This message is encrypted, with a strong encryption algorithm. It would be very difficult for an outsider to view the content of this message in a practical amount of time.") },
};

static const GdkRGBA smime_sign_colour[5] = {
	{ 0 }, { 0.53, 0.73, 0.53, 1 }, { 0.73, 0.53, 0.53, 1 }, { 0.91, 0.82, 0.13, 1 }, { 0 },
};

static void efhd_message_prefix	(EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable);
static void efhd_message_add_bar	(EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable);
static void efhd_parse_attachment	(EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable);
static void efhd_parse_secure		(EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable);
static void efhd_parse_optional		(EMFormat *emf, CamelMimePart *part, GString *part_id, EMFormatParserInfo *info, GCancellable *cancellable);

static GtkWidget * efhd_attachment_bar		(EMFormat *emf, EMFormatPURI *puri, GCancellable *cancellable);
static GtkWidget * efhd_attachment_button	(EMFormat *emf, EMFormatPURI *puri, GCancellable *cancellable);
static GtkWidget * efhd_attachment_optional	(EMFormat *emf, EMFormatPURI *puri, GCancellable *cancellable);

static void efhd_write_attachment_bar   (EMFormat *emf, EMFormatPURI *emp, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable);
static void efhd_write_attachment       (EMFormat *emf, EMFormatPURI *emp, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable);
static void efhd_write_secure_button    (EMFormat *emf, EMFormatPURI *emp, CamelStream *stream, EMFormatWriterInfo *info, GCancellable *cancellable);

static void efhd_free_attach_puri_data (EMFormatPURI *puri);

static void efhd_builtin_init (EMFormatHTMLDisplayClass *efhc);

static gpointer parent_class;

static EAttachmentStore *
find_parent_attachment_store (EMFormatHTMLDisplay *efhd,
                              const gchar *part_id)
{
	EMFormat *emf = (EMFormat *) efhd;
	EMFormatAttachmentBarPURI *abp;
	gchar *tmp, *pos;
	GList *item;

	tmp = g_strdup (part_id);

	do {
		gchar *id;

		pos = g_strrstr (tmp, ".");
		if (!pos)
			break;

		g_free (tmp);
		tmp = g_strndup (part_id, pos - tmp);
		id = g_strdup_printf ("%s.attachment-bar", tmp);

		item = g_hash_table_lookup (emf->mail_part_table, id);

		g_free (id);

	} while (pos && !item);

	g_free (tmp);

	abp = (EMFormatAttachmentBarPURI *) item->data;

	if (abp)
		return abp->store;
	else
		return NULL;
}

static void
efhd_attachment_bar_puri_free (EMFormatPURI *puri)
{
	EMFormatAttachmentBarPURI *abp;

	abp = (EMFormatAttachmentBarPURI *) puri;

	if (abp->store) {
		g_object_unref (abp->store);
		abp->store = NULL;
	}
}

static void
efhd_xpkcs7mime_free (EMFormatPURI *puri)
{
	EMFormatSMIMEPURI *sp = (EMFormatSMIMEPURI *) puri;

	if (sp->widget)
		gtk_widget_destroy (sp->widget);

	if (sp->description)
		g_free (sp->description);

	if (sp->valid)
		camel_cipher_validity_free (sp->valid);
}

static void
efhd_xpkcs7mime_info_response (GtkWidget *widget,
                               guint button,
                               EMFormatSMIMEPURI *po)
{
	gtk_widget_destroy (widget);
	po->widget = NULL;
}

#if defined (HAVE_NSS) && defined (ENABLE_SMIME)
static void
efhd_xpkcs7mime_viewcert_clicked (GtkWidget *button,
                                  EMFormatSMIMEPURI *po)
{
	CamelCipherCertInfo *info = g_object_get_data((GObject *)button, "e-cert-info");
	ECert *ec = NULL;

	if (info->cert_data)
		ec = e_cert_new (CERT_DupCertificate (info->cert_data));

	if (ec != NULL) {
		GtkWidget *w = certificate_viewer_show (ec);

		/* oddly enough certificate_viewer_show doesn't ... */
		gtk_widget_show (w);
		g_signal_connect (
			w, "response",
			G_CALLBACK (gtk_widget_destroy), NULL);

		if (w && po->widget)
			gtk_window_set_transient_for ((GtkWindow *) w, (GtkWindow *) po->widget);

		g_object_unref (ec);
	} else {
		g_warning("can't find certificate for %s <%s>", info->name?info->name:"", info->email?info->email:"");
	}
}
#endif

static void
efhd_xpkcs7mime_add_cert_table (GtkWidget *grid,
                                GQueue *certlist,
                                EMFormatSMIMEPURI *po)
{
	GList *head, *link;
	GtkTable *table;
	gint n = 0;

	table = (GtkTable *) gtk_table_new (certlist->length, 2, FALSE);

	head = g_queue_peek_head_link (certlist);

	for (link = head; link != NULL; link = g_list_next (link)) {
		CamelCipherCertInfo *info = link->data;
		gchar *la = NULL;
		const gchar *l = NULL;

		if (info->name) {
			if (info->email && strcmp (info->name, info->email) != 0)
				l = la = g_strdup_printf("%s <%s>", info->name, info->email);
			else
				l = info->name;
		} else {
			if (info->email)
				l = info->email;
		}

		if (l) {
			GtkWidget *w;
#if defined (HAVE_NSS) && defined (ENABLE_SMIME)
			ECert *ec = NULL;
#endif
			w = gtk_label_new (l);
			gtk_misc_set_alignment ((GtkMisc *) w, 0.0, 0.5);
			g_free (la);
			gtk_table_attach (table, w, 0, 1, n, n + 1, GTK_FILL, GTK_FILL, 3, 3);
#if defined (HAVE_NSS) && defined (ENABLE_SMIME)
			w = gtk_button_new_with_mnemonic(_("_View Certificate"));
			gtk_table_attach (table, w, 1, 2, n, n + 1, 0, 0, 3, 3);
			g_object_set_data((GObject *)w, "e-cert-info", info);
			g_signal_connect (
				w, "clicked",
				G_CALLBACK (efhd_xpkcs7mime_viewcert_clicked), po);

			if (info->cert_data)
				ec = e_cert_new (CERT_DupCertificate (info->cert_data));

			if (ec == NULL)
				gtk_widget_set_sensitive (w, FALSE);
			else
				g_object_unref (ec);
#else
			w = gtk_label_new (_("This certificate is not viewable"));
			gtk_table_attach (table, w, 1, 2, n, n + 1, 0, 0, 3, 3);
#endif
			n++;
		}
	}

	gtk_container_add (GTK_CONTAINER (grid), GTK_WIDGET (table));
}

static void
efhd_xpkcs7mime_validity_clicked (GtkWidget *button,
                                  EMFormatPURI *puri)
{
	EMFormatSMIMEPURI *po = (EMFormatSMIMEPURI *) puri;
	GtkBuilder *builder;
	GtkWidget *grid, *w;

	if (po->widget)
		/* FIXME: window raise? */
		return;

	builder = gtk_builder_new ();
	e_load_ui_builder_definition (builder, "mail-dialogs.ui");

	po->widget = e_builder_get_widget(builder, "message_security_dialog");

	grid = e_builder_get_widget(builder, "signature_grid");
	w = gtk_label_new (_(smime_sign_table[po->valid->sign.status].description));
	gtk_misc_set_alignment ((GtkMisc *) w, 0.0, 0.5);
	gtk_label_set_line_wrap ((GtkLabel *) w, TRUE);
	gtk_container_add (GTK_CONTAINER (grid), w);
	if (po->valid->sign.description) {
		GtkTextBuffer *buffer;

		buffer = gtk_text_buffer_new (NULL);
		gtk_text_buffer_set_text (buffer, po->valid->sign.description, strlen (po->valid->sign.description));
		w = g_object_new (gtk_scrolled_window_get_type (),
				 "hscrollbar_policy", GTK_POLICY_AUTOMATIC,
				 "vscrollbar_policy", GTK_POLICY_AUTOMATIC,
				 "shadow_type", GTK_SHADOW_IN,
				 "expand", TRUE,
				 "child", g_object_new(gtk_text_view_get_type(),
						       "buffer", buffer,
						       "cursor_visible", FALSE,
						       "editable", FALSE,
						       "width_request", 500,
						       "height_request", 160,
						       NULL),
				 NULL);
		g_object_unref (buffer);

		gtk_container_add (GTK_CONTAINER (grid), w);
	}

	if (!g_queue_is_empty (&po->valid->sign.signers))
		efhd_xpkcs7mime_add_cert_table (grid, &po->valid->sign.signers, po);

	gtk_widget_show_all (grid);

	grid = e_builder_get_widget(builder, "encryption_grid");
	w = gtk_label_new (_(smime_encrypt_table[po->valid->encrypt.status].description));
	gtk_misc_set_alignment ((GtkMisc *) w, 0.0, 0.5);
	gtk_label_set_line_wrap ((GtkLabel *) w, TRUE);
	gtk_container_add (GTK_CONTAINER (grid), w);
	if (po->valid->encrypt.description) {
		GtkTextBuffer *buffer;

		buffer = gtk_text_buffer_new (NULL);
		gtk_text_buffer_set_text (buffer, po->valid->encrypt.description, strlen (po->valid->encrypt.description));
		w = g_object_new (gtk_scrolled_window_get_type (),
				 "hscrollbar_policy", GTK_POLICY_AUTOMATIC,
				 "vscrollbar_policy", GTK_POLICY_AUTOMATIC,
				 "shadow_type", GTK_SHADOW_IN,
				 "expand", TRUE,
				 "child", g_object_new(gtk_text_view_get_type(),
						       "buffer", buffer,
						       "cursor_visible", FALSE,
						       "editable", FALSE,
						       "width_request", 500,
						       "height_request", 160,
						       NULL),
				 NULL);
		g_object_unref (buffer);

		gtk_container_add (GTK_CONTAINER (grid), w);
	}

	if (!g_queue_is_empty (&po->valid->encrypt.encrypters))
		efhd_xpkcs7mime_add_cert_table (grid, &po->valid->encrypt.encrypters, po);

	gtk_widget_show_all (grid);

	g_object_unref (builder);

	g_signal_connect (
	        po->widget, "response",
		G_CALLBACK (efhd_xpkcs7mime_info_response), po);

	gtk_widget_show (po->widget);
}

static GtkWidget *
efhd_xpkcs7mime_button (EMFormat *emf,
                        EMFormatPURI *puri,
                        GCancellable *cancellable)
{
	GtkWidget *box, *button, *layout, *widget;
	EMFormatSMIMEPURI *po = (EMFormatSMIMEPURI *) puri;
	const gchar *icon_name;

	/* FIXME: need to have it based on encryption and signing too */
	if (po->valid->sign.status != 0)
		icon_name = smime_sign_table[po->valid->sign.status].icon;
	else
		icon_name = smime_encrypt_table[po->valid->encrypt.status].icon;

	box = gtk_event_box_new ();
	if (po->valid->sign.status != 0)
		gtk_widget_override_background_color (box, GTK_STATE_FLAG_NORMAL,
			&smime_sign_colour[po->valid->sign.status]);

	layout = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
	gtk_container_add (GTK_CONTAINER (box), layout);

	button = gtk_button_new ();
	gtk_box_pack_start (GTK_BOX (layout), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
		G_CALLBACK (efhd_xpkcs7mime_validity_clicked), puri);

	widget = gtk_image_new_from_icon_name (
			icon_name, GTK_ICON_SIZE_LARGE_TOOLBAR);
	gtk_button_set_image (GTK_BUTTON (button), widget);

	widget = gtk_label_new (po->description);
	gtk_box_pack_start (GTK_BOX (layout), widget, FALSE, FALSE, 0);

	gtk_widget_show_all (box);

	return box;
}

struct attachment_load_data {
	EAttachment *attachment;
	EFlag *flag;
};

static void
attachment_loaded (EAttachment *attachment,
                   GAsyncResult *res,
                   gpointer user_data)
{
	struct attachment_load_data *data = user_data;
	EShell *shell;
	GtkWindow *window;

	shell = e_shell_get_default ();
	window = e_shell_get_active_window (shell);
	if (!E_IS_SHELL_WINDOW (window))
		window = NULL;

	e_attachment_load_handle_error (data->attachment, res, window);

	e_flag_set (data->flag);
}

/* Idle callback */
static gboolean
load_attachment_idle (struct attachment_load_data *data)
{
	e_attachment_load_async (data->attachment,
		(GAsyncReadyCallback) attachment_loaded, data);

	return FALSE;
}

static void
efhd_parse_attachment (EMFormat *emf,
                       CamelMimePart *part,
                       GString *part_id,
                       EMFormatParserInfo *info,
                       GCancellable *cancellable)
{
	gchar *text, *html;
	EMFormatHTMLDisplay *efhd = (EMFormatHTMLDisplay *) emf;
	EMFormatAttachmentPURI *puri;
	EAttachmentStore *store;
	const EMFormatHandler *handler;
	CamelContentType *ct;
	gchar *mime_type;
	gint len;
	const gchar *cid;
	guint32 size;
	struct attachment_load_data *load_data;
	gboolean can_show = FALSE;

	if (g_cancellable_is_cancelled (cancellable))
		return;

	len = part_id->len;
	g_string_append (part_id, ".attachment");

        /* Try to find handler for the mime part */
	ct = camel_mime_part_get_content_type (part);
	if (ct) {
		mime_type = camel_content_type_simple (ct);
		handler = em_format_find_handler (emf, mime_type);
	}

	/* FIXME: should we look up mime_type from object again? */
	text = em_format_describe_part (part, mime_type);
	html = camel_text_to_html (
		text, EM_FORMAT_HTML (emf)->text_html_flags &
		CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS, 0);
	g_free (text);
	g_free (mime_type);

	puri = (EMFormatAttachmentPURI *) em_format_puri_new (
			emf, sizeof (EMFormatAttachmentPURI), part, part_id->str);
	puri->puri.free = efhd_free_attach_puri_data;
	puri->puri.write_func = efhd_write_attachment;
	puri->puri.widget_func = efhd_attachment_button;
	puri->shown = (handler && em_format_is_inline (emf, part_id->str, part, handler));
	puri->snoop_mime_type = em_format_snoop_type (part);
	puri->attachment = e_attachment_new ();
	puri->attachment_view_part_id = NULL;
	puri->description = html;
	puri->handle = handler;
	if (info->validity)
		puri->puri.validity = camel_cipher_validity_clone (info->validity);

	cid = camel_mime_part_get_content_id (part);
	if (cid)
		puri->puri.cid = g_strdup_printf ("cid:%s", cid);

	if (handler) {
		CamelContentType *ct;

                /* This mime_type is important for WebKit to determine content type.
                 * We have converted text/ * to text/html, other (binary) formats remained
                 * untouched. */
		ct = camel_content_type_decode (handler->mime_type);
                if (g_strcmp0 (ct->type, "text") == 0)
                        puri->puri.mime_type = g_strdup ("text/html");
		else
			puri->puri.mime_type = camel_content_type_simple (ct);
		camel_content_type_unref (ct);
	}

	em_format_add_puri (emf, (EMFormatPURI *) puri);

        /* Though it is an attachment, we still might be able to parse it and
         * so discover some parts that we might be even able to display. */
	if (handler && handler->parse_func && (handler->parse_func != efhd_parse_attachment) &&
	    ((handler->flags & EM_FORMAT_HANDLER_COMPOUND_TYPE) ||
	     (handler->flags & EM_FORMAT_HANDLER_INLINE_DISPOSITION))) {
		GList *i;
		EMFormatParserInfo attachment_info = { .handler = handler,
						       .is_attachment = TRUE };
		handler->parse_func (emf, puri->puri.part, part_id, &attachment_info, cancellable);

		i = g_hash_table_lookup (emf->mail_part_table, part_id->str);
		if (i->next && i->next->data) {
			EMFormatPURI *p = i->next->data;
			puri->attachment_view_part_id = g_strdup (p->uri);
			can_show = TRUE;
		}
	}

	e_attachment_set_mime_part (puri->attachment, part);
	e_attachment_set_shown (puri->attachment, puri->shown);
	if (puri->puri.validity) {
		e_attachment_set_signed (puri->attachment, puri->puri.validity->sign.status);
		e_attachment_set_encrypted (puri->attachment, puri->puri.validity->encrypt.status);
	}
	e_attachment_set_can_show (puri->attachment,
		can_show || (puri->handle && puri->handle->write_func));

	store = find_parent_attachment_store (efhd, part_id->str);
	e_attachment_store_add_attachment (store, puri->attachment);

	if (emf->folder && emf->folder->summary && emf->message_uid) {
		CamelDataWrapper *dw = camel_medium_get_content (CAMEL_MEDIUM (puri->puri.part));
		GByteArray *ba;
		ba = camel_data_wrapper_get_byte_array (dw);
		if (ba) {
			size = ba->len;

			if (camel_mime_part_get_encoding (puri->puri.part) == CAMEL_TRANSFER_ENCODING_BASE64)
				size = size / 1.37;
		}
	}

	load_data = g_new0 (struct attachment_load_data, 1);
	load_data->attachment = g_object_ref (puri->attachment);
	load_data->flag = e_flag_new ();

	e_flag_clear (load_data->flag);

	/* e_attachment_load_async must be called from main thread */
	g_idle_add ((GSourceFunc) load_attachment_idle, load_data);

	e_flag_wait (load_data->flag);

	e_flag_free (load_data->flag);
	g_object_unref (load_data->attachment);
	g_free (load_data);

	if (size != 0) {
		GFileInfo *fileinfo;

		fileinfo = e_attachment_get_file_info (puri->attachment);
		g_file_info_set_size (fileinfo, size);
		e_attachment_set_file_info (puri->attachment, fileinfo);
	}

	g_string_truncate (part_id, len);
}

static void
efhd_parse_optional (EMFormat *emf,
                     CamelMimePart *part,
                     GString *part_id,
                     EMFormatParserInfo *info,
                     GCancellable *cancellable)
{
	EMFormatAttachmentPURI *puri;
	gint len;

	len = part_id->len;
        g_string_append (part_id, ".optional");

	puri = (EMFormatAttachmentPURI *) em_format_puri_new (
			emf, sizeof (EMFormatAttachmentPURI), part, part_id->str);
	puri->puri.free = efhd_free_attach_puri_data;
	puri->puri.write_func = efhd_write_attachment;
	puri->puri.widget_func = efhd_attachment_optional;
	puri->attachment_view_part_id = g_strdup (part_id->str);
	puri->handle = em_format_find_handler (emf, "text/plain");
	puri->shown = FALSE;
	puri->snoop_mime_type = "text/plain";
	puri->attachment = e_attachment_new ();
	e_attachment_set_mime_part (puri->attachment, puri->puri.part);
	puri->description = g_strdup(_("Evolution cannot render this email as it is too "
				       "large to process. You can view it unformatted or "
				       "with an external text editor."));

	puri->mstream = CAMEL_STREAM_MEM (camel_stream_mem_new ());
	camel_data_wrapper_decode_to_stream_sync ((CamelDataWrapper *) part,
		(CamelStream *) puri->mstream, cancellable, NULL);

	if (info->validity) {
		puri->puri.validity = camel_cipher_validity_clone (info->validity);
	}

	em_format_add_puri (emf, (EMFormatPURI *) puri);

	g_string_truncate (part_id, len);
}

static void
efhd_parse_secure (EMFormat *emf,
                   CamelMimePart *part,
                   GString *part_id,
                   EMFormatParserInfo *info,
                   GCancellable *cancellable)
{
	if (info->validity
	    && (info->validity->encrypt.status != CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE
		|| info->validity->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE)) {
		GString *buffer;
		EMFormatSMIMEPURI *pobj;

		pobj = (EMFormatSMIMEPURI *) em_format_puri_new (
				emf, sizeof (EMFormatSMIMEPURI), part, part_id->str);
		pobj->puri.free = efhd_xpkcs7mime_free;
		pobj->valid = camel_cipher_validity_clone (info->validity);
		pobj->puri.widget_func = efhd_xpkcs7mime_button;
		pobj->puri.write_func = efhd_write_secure_button;

		em_format_add_puri (emf, (EMFormatPURI *) pobj);

		buffer = g_string_new ("");

		if (info->validity->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE) {
			const gchar *desc;
			gint status;

			status = info->validity->sign.status;
			desc = smime_sign_table[status].shortdesc;

			g_string_append (buffer, gettext (desc));

			em_format_html_format_cert_infos (
				&info->validity->sign.signers, buffer);
		}

		if (info->validity->encrypt.status != CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE) {
			const gchar *desc;
			gint status;

			if (info->validity->sign.status != CAMEL_CIPHER_VALIDITY_SIGN_NONE)
				g_string_append (buffer, "\n");

			status = info->validity->encrypt.status;
			desc = smime_encrypt_table[status].shortdesc;
			g_string_append (buffer, gettext (desc));
		}

		pobj->description = g_string_free (buffer, FALSE);
	}
}

/******************************************************************************/
static void
efhd_write_attachment_bar (EMFormat *emf,
                           EMFormatPURI *puri,
                           CamelStream *stream,
                           EMFormatWriterInfo *info,
                           GCancellable *cancellable)
{
	EMFormatAttachmentBarPURI *efab = (EMFormatAttachmentBarPURI *) puri;
	gchar *str;

	if (info->mode == EM_FORMAT_WRITE_MODE_PRINTING)
		return;

	if (e_attachment_store_get_num_attachments (efab->store) == 0)
		return;

	str = g_strdup_printf (
                "<object type=\"application/x-attachment-bar\" "
			"height=\"20\" width=\"100%%\" "
                        "id=\"%s\"data=\"%s\"></object>", puri->uri, puri->uri);

	camel_stream_write_string (stream, str, cancellable, NULL);

	g_free (str);
}

static void
efhd_write_attachment (EMFormat *emf,
                       EMFormatPURI *puri,
                       CamelStream *stream,
                       EMFormatWriterInfo *info,
                       GCancellable *cancellable)
{
	gchar *str, *desc;
	const gchar *mime_type;
	gchar *button_id;

	EMFormatAttachmentPURI *efa = (EMFormatAttachmentPURI *) puri;

        /* If the attachment is requested as RAW, then call the handler directly
         * and do not append any other code. */
	if ((info->mode == EM_FORMAT_WRITE_MODE_RAW) &&
	    efa->handle && efa->handle->write_func) {

		efa->handle->write_func (emf, puri, stream, info, cancellable);
		return;
	}

	if (info->mode == EM_FORMAT_WRITE_MODE_PRINTING) {

		if (efa->handle && efa->handle->write_func)
			efa->handle->write_func (emf, puri, stream, info, cancellable);

		return;
	}

	if (efa->handle)
		mime_type = efa->handle->mime_type;
	else
		mime_type = efa->snoop_mime_type;

        button_id = g_strconcat (puri->uri, ".attachment_button", NULL);

	desc = em_format_describe_part (puri->part, mime_type);
	str = g_strdup_printf (
                "<div class=\"attachment\">"
                "<table width=\"100%%\" border=\"0\">"
                "<tr valign=\"middle\">"
                "<td align=\"left\" width=\"100\">"
                "<object type=\"application/x-attachment-button\" "
		"height=\"20\" width=\"100\" data=\"%s\" id=\"%s\"></object>"
                "</td>"
                "<td align=\"left\">%s</td>"
                "</tr>", puri->uri, button_id, desc);

	camel_stream_write_string (stream, str, cancellable, NULL);
	g_free (desc);
	g_free (button_id);
	g_free (str);

        /* If we know how to write the attachment, then do it */
	if ((efa->handle && efa->handle->write_func) ||
	    (efa->attachment_view_part_id)) {

		str = g_strdup_printf (
                        "<tr><td colspan=\"2\">"
                        "<div class=\"attachment-wrapper\" id=\"%s\">",
			puri->uri);

		camel_stream_write_string (stream, str, cancellable, NULL);
		g_free (str);

		if (efa->handle->write_func) {
			efa->handle->write_func (
				emf, puri, stream, info, cancellable);
		} else if (efa->attachment_view_part_id) {
			EMFormatPURI *p;

			p = em_format_find_puri (
				emf, efa->attachment_view_part_id);
			if (p && p->write_func)
				p->write_func (emf, p, stream, info, cancellable);
		}

                camel_stream_write_string (stream, "</div></td></tr>", cancellable, NULL);
	}

        camel_stream_write_string (stream, "</table></div>", cancellable, NULL);
}

static void
efhd_write_secure_button (EMFormat *emf,
                          EMFormatPURI *puri,
                          CamelStream *stream,
                          EMFormatWriterInfo *info,
                          GCancellable *cancellable)
{
	gchar *str;

	if ((info->mode != EM_FORMAT_WRITE_MODE_NORMAL) &&
	    (info->mode != EM_FORMAT_WRITE_MODE_RAW))
		return;

	str = g_strdup_printf (
                "<object type=\"application/x-secure-button\" "
                "height=\"20\" width=\"100%%\" "
                "data=\"%s\" id=\"%s\"></object>", puri->uri, puri->uri);

	camel_stream_write_string (stream, str, cancellable, NULL);

	g_free (str);
}

static void
efhd_finalize (GObject *object)
{
	EMFormatHTMLDisplay *efhd;

	efhd = EM_FORMAT_HTML_DISPLAY (object);
	g_return_if_fail (efhd != NULL);

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

static void
efhd_preparse (EMFormat *emf)
{
	EMFormatHTMLDisplay *efhd = (EMFormatHTMLDisplay *) emf;

	efhd->priv->last_view = NULL;
}

static void
efhd_class_init (EMFormatHTMLDisplayClass *class)
{
	GObjectClass *object_class;
	EMFormatHTMLClass *format_html_class;
	EMFormatClass *format_class;

	parent_class = g_type_class_peek_parent (class);
	g_type_class_add_private (class, sizeof (EMFormatHTMLDisplayPrivate));

	object_class = G_OBJECT_CLASS (class);
	object_class->finalize = efhd_finalize;

	format_html_class = EM_FORMAT_HTML_CLASS (class);
	format_html_class->html_widget_type = E_TYPE_MAIL_DISPLAY;

	format_class = EM_FORMAT_CLASS (class);
	format_class->preparse = efhd_preparse;

	efhd_builtin_init (class);
}

static void
efhd_init (EMFormatHTMLDisplay *efhd)
{
	efhd->priv = EM_FORMAT_HTML_DISPLAY_GET_PRIVATE (efhd);

        /* we want to convert url's etc */
	EM_FORMAT_HTML (efhd)->text_html_flags |=
		CAMEL_MIME_FILTER_TOHTML_CONVERT_URLS |
		CAMEL_MIME_FILTER_TOHTML_CONVERT_ADDRESSES;

}

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

	if (G_UNLIKELY (type == 0)) {
		static const GTypeInfo type_info = {
			sizeof (EMFormatHTMLDisplayClass),
			(GBaseInitFunc) NULL,
			(GBaseFinalizeFunc) NULL,
			(GClassInitFunc) efhd_class_init,
			(GClassFinalizeFunc) NULL,
			NULL,  /* class_data */
			sizeof (EMFormatHTMLDisplay),
			0,     /* n_preallocs */
			(GInstanceInitFunc) efhd_init,
			NULL   /* value_table */
		};

		type = g_type_register_static (
			EM_TYPE_FORMAT_HTML, "EMFormatHTMLDisplay",
			&type_info, 0);
	}

	return type;
}

EMFormatHTMLDisplay *
em_format_html_display_new (CamelSession *session)
{
	g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);

	return g_object_new (
		EM_TYPE_FORMAT_HTML_DISPLAY,
		"session", session, NULL);
}

/* ********************************************************************** */

static EMFormatHandler type_builtin_table[] = {
	{ (gchar *) "x-evolution/message/prefix", efhd_message_prefix, },
	{ (gchar *) "x-evolution/message/attachment-bar", (EMFormatParseFunc) efhd_message_add_bar, efhd_write_attachment_bar, },
	{ (gchar *) "x-evolution/message/attachment", efhd_parse_attachment, efhd_write_attachment, },
	{ (gchar *) "x-evolution/message/x-secure-button", efhd_parse_secure, efhd_write_secure_button, },
	{ (gchar *) "x-evolution/message/optional", efhd_parse_optional, },
};

static void
efhd_builtin_init (EMFormatHTMLDisplayClass *efhc)
{
	gint i;

	EMFormatClass *emfc = (EMFormatClass *) efhc;

	for (i = 0; i < G_N_ELEMENTS (type_builtin_table); i++)
		em_format_class_add_handler (emfc, &type_builtin_table[i]);
}

static void
efhd_message_prefix (EMFormat *emf,
                     CamelMimePart *part,
                     GString *part_id,
                     EMFormatParserInfo *info,
                     GCancellable *cancellable)
{
	const gchar *flag, *comp, *due;
	time_t date;
	gchar *iconpath, *due_date_str;
	GString *buffer;
	EMFormatAttachmentPURI *puri;

	if (emf->folder == NULL || emf->message_uid == NULL
	    || (flag = camel_folder_get_message_user_tag(emf->folder, emf->message_uid, "follow-up")) == NULL
	    || flag[0] == 0)
		return;

	puri = (EMFormatAttachmentPURI *) em_format_puri_new (
			emf, sizeof (EMFormatAttachmentPURI), part, ".message_prefix");

	puri->attachment_view_part_id = g_strdup (part_id->str);

	comp = camel_folder_get_message_user_tag(emf->folder, emf->message_uid, "completed-on");
	iconpath = e_icon_factory_get_icon_filename (comp && comp[0] ? "stock_mail-flag-for-followup-done" : "stock_mail-flag-for-followup", GTK_ICON_SIZE_MENU);
	if (iconpath) {
		gchar *classid;

		classid = g_strdup_printf (
			"icon:///em-format-html-display/%s/%s",
			part_id->str,
			comp && comp[0] ? "comp" : "uncomp");

		puri->puri.uri = classid;

		g_free (classid);
	}

	buffer = g_string_new ("");

	if (comp && comp[0]) {
		date = camel_header_decode_date (comp, NULL);
		due_date_str = e_datetime_format_format (
			"mail", "header", DTFormatKindDateTime, date);
		g_string_append_printf (
			buffer, "%s, %s %s",
			flag, _("Completed on"),
			due_date_str ? due_date_str : "???");
		g_free (due_date_str);
	} else if ((due = camel_folder_get_message_user_tag(emf->folder, emf->message_uid, "due-by")) != NULL && due[0]) {
		time_t now;

		date = camel_header_decode_date (due, NULL);
		now = time (NULL);
		if (now > date)
			g_string_append_printf (
				buffer,
				"<b>%s</b> ",
				_("Overdue:"));

		due_date_str = e_datetime_format_format (
			"mail", "header", DTFormatKindDateTime, date);
		/* Translators: the "by" is part of the string,
		 * like "Follow-up by Tuesday, January 13, 2009" */
		g_string_append_printf (
			buffer, "%s %s %s",
			flag, _("by"),
			due_date_str ? due_date_str : "???");
		g_free (due_date_str);
	} else {
		g_string_append (buffer, flag);
	}

	puri->description = g_string_free (buffer, FALSE);
}

/* ********************************************************************** */

/* attachment button callback */
static GtkWidget *
efhd_attachment_button (EMFormat *emf,
                        EMFormatPURI *puri,
                        GCancellable *cancellable)
{
	EMFormatAttachmentPURI *info = (EMFormatAttachmentPURI *) puri;
	GtkWidget *widget;

	/* FIXME: handle default shown case */
	d(printf("adding attachment button/content\n"));

	if (g_cancellable_is_cancelled (cancellable))
		return NULL;

	if (!info || info->forward) {
		g_warning ("unable to expand the attachment\n");
		return NULL;
	}

	widget = e_attachment_button_new ();
        g_object_set_data (G_OBJECT (widget), "uri", puri->uri);
	e_attachment_button_set_attachment (
		E_ATTACHMENT_BUTTON (widget), info->attachment);
	e_attachment_button_set_view (
		E_ATTACHMENT_BUTTON (widget),
		EM_FORMAT_HTML_DISPLAY (emf)->priv->last_view);

	gtk_widget_set_can_focus (widget, TRUE);
	gtk_widget_show (widget);

	return widget;
}

static GtkWidget *
efhd_attachment_bar (EMFormat *emf,
                     EMFormatPURI *puri,
                     GCancellable *cancellable)
{
	EMFormatAttachmentBarPURI *abp = (EMFormatAttachmentBarPURI *) puri;
	GtkWidget *widget;

	widget = e_mail_attachment_bar_new (abp->store);
	EM_FORMAT_HTML_DISPLAY (emf)->priv->last_view = (EAttachmentView *) widget;

	return widget;
}

static void
efhd_message_add_bar (EMFormat *emf,
                      CamelMimePart *part,
                      GString *part_id,
                      EMFormatParserInfo *info,
                      GCancellable *cancellable)
{
	EMFormatAttachmentBarPURI *puri;
	gint len;

	if (g_cancellable_is_cancelled (cancellable))
		return;

	len = part_id->len;
	g_string_append (part_id, ".attachment-bar");
	puri = (EMFormatAttachmentBarPURI *) em_format_puri_new (
			emf, sizeof (EMFormatAttachmentBarPURI), part, part_id->str);
	puri->puri.write_func = efhd_write_attachment_bar;
	puri->puri.widget_func = efhd_attachment_bar;
	puri->puri.free = efhd_attachment_bar_puri_free;
	puri->store = E_ATTACHMENT_STORE (e_attachment_store_new ());

	em_format_add_puri (emf, (EMFormatPURI *) puri);

	g_string_truncate (part_id, len);
}

static void
efhd_optional_button_show (GtkWidget *widget,
                           GtkWidget *w)
{
	GtkWidget *label = g_object_get_data (G_OBJECT (widget), "text-label");

	if (gtk_widget_get_visible (w)) {
		gtk_widget_hide (w);
		gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("View _Unformatted"));
	} else {
		gtk_label_set_text_with_mnemonic (GTK_LABEL (label), _("Hide _Unformatted"));
		gtk_widget_show (w);
	}
}

/* optional render attachment button callback */
static GtkWidget *
efhd_attachment_optional (EMFormat *efh,
                          EMFormatPURI *puri,
                          GCancellable *cancellable)
{
	GtkWidget *hbox, *vbox, *button, *mainbox, *scroll, *label, *img;
	AtkObject *a11y;
	GtkWidget *view;
	GtkTextBuffer *buffer;
	GByteArray *byte_array;
	EMFormatAttachmentPURI *info = (EMFormatAttachmentPURI *) puri;

	if (g_cancellable_is_cancelled (cancellable))
		return NULL;

	/* FIXME: handle default shown case */
	d(printf("adding attachment button/content for optional rendering\n"));

	if (!info || info->forward) {
		g_warning ("unable to expand the attachment\n");
		return NULL;
	}

	scroll = gtk_scrolled_window_new (NULL, NULL);
	mainbox = gtk_hbox_new (FALSE, 0);

	button = gtk_button_new ();
	hbox = gtk_hbox_new (FALSE, 0);
	img = gtk_image_new_from_icon_name (
		"stock_show-all", GTK_ICON_SIZE_BUTTON);
	label = gtk_label_new_with_mnemonic(_("View _Unformatted"));
	g_object_set_data (G_OBJECT (button), "text-label", (gpointer)label);
	gtk_box_pack_start (GTK_BOX (hbox), img, TRUE, TRUE, 2);
	gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 2);
	gtk_widget_show_all (hbox);
	gtk_container_add (GTK_CONTAINER (button), GTK_WIDGET (hbox));
	if (info->handle)
		g_signal_connect (
			button, "clicked",
			G_CALLBACK (efhd_optional_button_show), scroll);
	else {
		gtk_widget_set_sensitive (button, FALSE);
		gtk_widget_set_can_focus (button, FALSE);
	}

	vbox = gtk_vbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (mainbox), button, FALSE, FALSE, 6);

	button = gtk_button_new ();
	hbox = gtk_hbox_new (FALSE, 0);
	img = gtk_image_new_from_stock (
		GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
	label = gtk_label_new_with_mnemonic(_("O_pen With"));
	gtk_box_pack_start (GTK_BOX (hbox), img, TRUE, TRUE, 2);
	gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 2);
	gtk_box_pack_start (GTK_BOX (hbox), gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE), TRUE, TRUE, 2);
	gtk_widget_show_all (hbox);
	gtk_container_add (GTK_CONTAINER (button), GTK_WIDGET (hbox));

	a11y = gtk_widget_get_accessible (button);
	/* Translators: Name of an Attachment button for a11y object */
	atk_object_set_name (a11y, C_("Button", "Attachment"));

	gtk_box_pack_start (GTK_BOX (mainbox), button, FALSE, FALSE, 6);

	gtk_widget_show_all (mainbox);

	gtk_box_pack_start (GTK_BOX (vbox), mainbox, FALSE, FALSE, 6);

	view = gtk_text_view_new ();
	gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
	gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
	buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
	byte_array = camel_stream_mem_get_byte_array (info->mstream);
	gtk_text_buffer_set_text (
		buffer, (gchar *) byte_array->data, byte_array->len);
	g_object_unref (info->mstream);
	info->mstream = NULL;
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
					GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
	gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET (view));
	gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 6);
	gtk_widget_show (GTK_WIDGET (view));

	if (!info->shown)
		gtk_widget_hide (scroll);

	gtk_widget_show (vbox);
	info->handle = NULL;

	return view;
}

static void
efhd_free_attach_puri_data (EMFormatPURI *puri)
{
	EMFormatAttachmentPURI *info = (EMFormatAttachmentPURI *) puri;

	g_return_if_fail (puri != NULL);

	if (info->attachment) {
		g_object_unref (info->attachment);
		info->attachment = NULL;
	}

	if (info->description) {
		g_free (info->description);
		info->description = NULL;
	}

	if (info->attachment_view_part_id) {
		g_free (info->attachment_view_part_id);
		info->attachment_view_part_id = NULL;
	}

	if (info->mstream) {
		g_object_unref (info->mstream);
		info->mstream = NULL;
	}
}