[evolution-patches] Patch to resize images

[Srinivasa Ragavan <sragavan novell com>]

Hi,

This is a first cut patch, with few pending issues

I have attached the patch. Please review the patch.

-Srini.

--- /dev/null	2005-03-20 01:06:14.000000000 +0530
+++ em-image-stream.c	2005-06-23 10:18:05.000000000 +0530
@@ -0,0 +1,216 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Authors: Srinivasa Ragavan <sragavan novell com>
+ *
+ * Copyright 2005 Novell, Inc. (www.novell.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk-pixbuf/gdk-pixbuf-loader.h>
+#ifdef HAVE_LIBGNOMEUI_GNOME_THUMBNAIL_H
+#include <libgnomeui/gnome-thumbnail.h>
+#endif
+#include <gtk/gtkimage.h>
+#include "em-image-stream.h"
+
+#include "libedataserver/e-msgport.h"
+
+#define d(x) 
+
+static void em_image_stream_class_init (EMImageStreamClass *klass);
+static void em_image_stream_init (CamelObject *object);
+static void em_image_stream_finalize (CamelObject *object);
+
+static ssize_t emis_sync_write(CamelStream *stream, const char *buffer, size_t n);
+static int emis_sync_close(CamelStream *stream);
+static int emis_sync_flush(CamelStream *stream);
+
+static EMSyncStreamClass *parent_class = NULL;
+
+CamelType
+em_image_stream_get_type (void)
+{
+	static CamelType type = CAMEL_INVALID_TYPE;
+	
+	if (type == CAMEL_INVALID_TYPE) {
+		parent_class = (EMSyncStreamClass *)em_sync_stream_get_type();
+		type = camel_type_register (em_sync_stream_get_type(),
+					    "EMImageStream",
+					    sizeof (EMImageStream),
+					    sizeof (EMImageStreamClass),
+					    (CamelObjectClassInitFunc) em_image_stream_class_init,
+					    NULL,
+					    (CamelObjectInitFunc) em_image_stream_init,
+					    (CamelObjectFinalizeFunc) em_image_stream_finalize);
+	}
+	
+	return type;
+}
+
+static void
+em_image_stream_class_init (EMImageStreamClass *klass)
+{
+	((EMSyncStreamClass *)klass)->sync_write = emis_sync_write;
+	((EMSyncStreamClass *)klass)->sync_flush = emis_sync_flush;
+	((EMSyncStreamClass *)klass)->sync_close = emis_sync_close;
+}
+
+static void
+em_image_stream_init (CamelObject *object)
+{
+	EMImageStream *emis = (EMImageStream *)object;
+
+	emis->width = 24;
+	emis->height = 24;
+}
+
+static void
+emis_cleanup(EMImageStream *emis)
+{
+	if (emis->loader) {
+		gdk_pixbuf_loader_close(emis->loader, NULL);
+		g_object_unref(emis->loader);
+		emis->loader = NULL;
+	}
+
+	if (emis->destroy_id) {
+		g_signal_handler_disconnect(emis->image, emis->destroy_id);
+		emis->destroy_id = 0;
+	}
+
+	g_free(emis->key);
+	emis->key = NULL;
+
+	emis->image = NULL;
+	emis->sync.cancel = TRUE;
+}
+
+static void
+em_image_stream_finalize(CamelObject *object)
+{
+	EMImageStream *emis = (EMImageStream *)object;
+
+	emis_cleanup(emis);
+}
+
+static ssize_t
+emis_sync_write(CamelStream *stream, const char *buffer, size_t n)
+{
+	EMImageStream *emis = EM_IMAGE_STREAM (stream);
+
+	if (emis->loader == NULL)
+		return -1;
+
+	if (!gdk_pixbuf_loader_write(emis->loader, buffer, n, NULL)) {
+		emis_cleanup(emis);
+		return -1;
+	}
+
+	return (ssize_t) n;
+}
+
+static int
+emis_sync_flush(CamelStream *stream)
+{
+	return 0;
+}
+
+static int
+emis_sync_close(CamelStream *stream)
+{
+	EMImageStream *emis = (EMImageStream *)stream;
+	int width, height;
+	float ratio;
+	GdkPixbuf *pixbuf, *mini, *orig;
+
+	if (emis->loader == NULL)
+		return -1;
+
+	gdk_pixbuf_loader_close(emis->loader, NULL);
+
+	pixbuf = gdk_pixbuf_loader_get_pixbuf(emis->loader);
+	if (pixbuf == NULL) {
+		d(printf("couldn't get pixbuf from loader\n"));
+		emis_cleanup(emis);
+		return -1;
+	}
+
+	width = gdk_pixbuf_get_width(pixbuf);
+	height = gdk_pixbuf_get_height(pixbuf);
+	
+	/*FIXME: How to free this? */
+	orig = gdk_pixbuf_copy (pixbuf);	
+	g_object_set_data_full (emis->image, "alt-image", orig, g_object_unref);
+	g_object_set_data (emis->image, "original-width", width);
+	g_object_set_data (emis->image, "original-height", height);
+	
+
+	if (width > emis->width) {
+		ratio = (float)width / (float)emis->width;
+		width = (int) (width / ratio);
+		height = (int) (height / ratio);
+		g_object_set_data (emis->image, "re-sized", 1);		
+	} else {
+		g_object_set_data (emis->image, "re-sized", 0);		
+	}
+	
+	orig = gdk_pixbuf_copy (pixbuf);
+#ifdef HAVE_LIBGNOMEUI_GNOME_THUMBNAIL_H
+	mini = gnome_thumbnail_scale_down_pixbuf (pixbuf, width, height);
+#else
+	mini = gdk_pixbuf_scale_simple(pixbuf, width, height, GDK_INTERP_BILINEAR);
+#endif
+	gtk_image_set_from_pixbuf(emis->image, mini);
+
+	pixbuf = mini;
+
+	/* FIXME: Do we have to free this? */
+
+	g_object_unref(emis->loader);
+	emis->loader = NULL;
+
+	g_signal_handler_disconnect(emis->image, emis->destroy_id);
+	emis->destroy_id = 0;
+	return 0;
+}
+
+static void
+emis_image_destroy(struct _GtkImage *image, EMImageStream *emis)
+{
+	emis_cleanup(emis);
+}
+
+CamelStream *
+em_image_stream_new(GtkImage *image, const char *key, int width)
+{
+	EMImageStream *new;
+
+	new = EM_IMAGE_STREAM(camel_object_new(EM_IMAGE_STREAM_TYPE));
+	new->image = image;
+	new->destroy_id = g_signal_connect(image, "destroy", G_CALLBACK(emis_image_destroy), new);
+	new->loader = gdk_pixbuf_loader_new();
+	new->key = g_strdup(key);
+	new->width = width;
+
+	return (CamelStream *)new;
+}
--- /dev/null	2005-03-20 01:06:14.000000000 +0530
+++ em-image-stream.h	2005-06-23 10:18:03.000000000 +0530
@@ -0,0 +1,63 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Authors: Srinivasa Ragavan <sragavan novell com>
+ *
+ * Copyright 2005 Novell, Inc. (www.novell.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ *
+ * 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
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifndef EM_IMAGE_STREAM_H
+#define EM_IMAGE_STREAM_H
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+#define EM_IMAGE_STREAM_TYPE     (em_image_stream_get_type ())
+#define EM_IMAGE_STREAM(obj)     (CAMEL_CHECK_CAST((obj), EM_IMAGE_STREAM_TYPE, EMImageStream))
+#define EM_IMAGE_STREAM_CLASS(k) (CAMEL_CHECK_CLASS_CAST ((k), EM_IMAGE_STREAM_TYPE, EMImageStreamClass))
+#define EM_IS_IMAGE_STREAM(o)    (CAMEL_CHECK_TYPE((o), EM_IMAGE_STREAM_TYPE))
+
+struct _GtkHTML;
+struct _GtkIconStream;
+
+#include "mail/em-sync-stream.h"
+
+typedef struct _EMImageStream {
+	EMSyncStream sync;
+
+	unsigned int width, height;
+	guint destroy_id;
+	struct _GdkPixbufLoader *loader;
+	struct _GtkImage *image;
+	char *key;
+} EMImageStream;
+
+typedef struct {
+	EMSyncStreamClass parent_class;
+} EMImageStreamClass;
+
+CamelType    em_image_stream_get_type (void);
+
+CamelStream *em_image_stream_new(GtkImage *image, const char *key, int width);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* EM_IMAGE_STREAM_H */
Index: Makefile.am
===================================================================
RCS file: /cvs/gnome/evolution/mail/Makefile.am,v
retrieving revision 1.263
diff -u -r1.263 Makefile.am
--- Makefile.am	2 Jun 2005 04:30:16 -0000	1.263
+++ Makefile.am	23 Jun 2005 09:19:19 -0000
@@ -103,7 +103,8 @@
 	mail-session.h				\
 	mail-tools.h				\
 	message-list.h				\
-	mail-vfolder.h
+	mail-vfolder.h				\
+	em-image-stream.h			
 
 # libevolution-mail
 
@@ -206,7 +207,9 @@
 	message-tag-editor.c			\
 	message-tag-editor.h			\
 	message-tag-followup.c			\
-	message-tag-followup.h
+	message-tag-followup.h			\
+	em-image-stream.c			\
+	em-image-stream.h			
 
 if ENABLE_SMIME
 SMIME_LIB=$(top_builddir)/smime/gui/libevolution-smime.la
Index: em-format-html-display.c
===================================================================
RCS file: /cvs/gnome/evolution/mail/em-format-html-display.c,v
retrieving revision 1.68
diff -u -r1.68 em-format-html-display.c
--- em-format-html-display.c	17 Jun 2005 15:20:29 -0000	1.68
+++ em-format-html-display.c	23 Jun 2005 09:19:20 -0000
@@ -119,6 +119,8 @@
 	GtkHTML *frame;
 	CamelStream *output;
 	unsigned int shown:1;
+	unsigned int size:1;
+	GtkWidget *image;
 };
 
 static void efhd_iframe_created(GtkHTML *html, GtkHTML *iframe, EMFormatHTMLDisplay *efh);
@@ -1059,10 +1061,29 @@
 	efhd_attachment_show(NULL, NULL, data);
 }
 
+static void
+efhd_image_resize (EPopup *ep, EPopupItem *item, void *data)
+{
+	struct _attach_puri *info = data;
+	GdkPixbuf *tmp;
+	
+	if (info->image) {
+		/* Swap the alt pixbuf and the current pixbuf of the shown GtkImage */
+		tmp = g_object_steal_data (info->image, "alt-image");
+		g_object_set_data_full (info->image, "alt-image", gtk_image_get_pixbuf (info->image), g_object_unref);
+		gtk_image_set_from_pixbuf (info->image, tmp);
+		info->size = ~info->size;
+		gtk_widget_show (info->image);
+	}
+}
+
 static EPopupItem efhd_menu_items[] = {
 	{ E_POPUP_BAR, "05.display", },
 	{ E_POPUP_ITEM, "05.display.00", N_("_View Inline"), efhd_attachment_show },
 	{ E_POPUP_ITEM, "05.display.00", N_("_Hide"), efhd_attachment_show },
+	{ E_POPUP_ITEM, "05.display.01", N_("_Fit to Width"), efhd_image_resize, NULL, NULL, EM_POPUP_PART_IMAGE },
+	{ E_POPUP_ITEM, "05.display.01", N_("Show _Original Size"), efhd_image_resize, NULL, NULL, EM_POPUP_PART_IMAGE },
+
 };
 
 static void
@@ -1115,6 +1136,10 @@
 		menus = g_slist_prepend(menus, &efhd_menu_items[0]);
 		item = &efhd_menu_items[info->shown?2:1];
 		menus = g_slist_prepend(menus, item);
+		if ( info->shown && info->image && g_object_get_data (info->image, "re-sized")) {
+			item = &efhd_menu_items[info->size?4:3];
+			menus = g_slist_prepend(menus, item);			
+		}
 	}
 
 	e_popup_add_items((EPopup *)emp, menus, NULL, efhd_menu_items_free, info);
@@ -1129,6 +1154,17 @@
 }
 
 static gboolean
+efhd_image_popup(GtkWidget *w, GdkEventButton *event, struct _attach_puri *info)
+{
+	if (event && event->button != 3) {
+		/* ?? gtk_propagate_event(GTK_WIDGET (user_data), (GdkEvent *)event);*/
+		return FALSE;
+	}
+	efhd_attachment_popup(w, event, info);
+
+}
+
+static gboolean
 efhd_attachment_popup_menu(GtkWidget *w, struct _attach_puri *info)
 {
 	return efhd_attachment_popup(w, NULL, info);
@@ -1489,6 +1525,157 @@
 	gnome_vfs_mime_component_list_free (components);
 
 	return component != NULL;
+}
+
+static void
+efhd_image_resize_callback (GtkWidget *w, GtkAllocation *event, struct _attach_puri *info)
+{
+	GdkPixbuf *original, *reduced, *shrunk;
+	int new_width = ((GtkWidget *)((EMFormatHTML *)info->puri.format)->html)->allocation.width;
+	int width, height;
+	float ratio;
+
+	new_width = new_width * 95 / 100;
+	
+	if (g_object_get_data (info->image, "re-sized")) {
+		/* It is a resized image */
+		width = g_object_get_data (info->image, "original-width");
+		height = g_object_get_data (info->image, "original-height");
+		ratio = (float)width / (float) new_width;
+		
+		if (new_width > width) {
+			/* If the window size go beyond the image size, lets not resize any more */
+			if (info->size) {
+				/* Restore the original image */
+				original = gdk_pixbuf_copy (g_object_get_data (info->image, "alt-image"));
+				gtk_image_set_from_pixbuf (info->image, original);
+			}
+			g_object_set_data (info->image, "re-sized", 0);
+			return;
+		}
+
+		width = new_width;
+		height = (int) (height/ratio);
+
+		/* To keep the quality of image, we always resize from the original image */
+		if (info->size) {
+			/* Original is the alt image */
+			original = gdk_pixbuf_copy (g_object_get_data (info->image, "alt-image"));
+			reduced = gtk_image_get_pixbuf (info->image);
+		} else {
+			/* The original image is only shown */
+			original = gtk_image_get_pixbuf (info->image);
+			reduced = gdk_pixbuf_copy (g_object_get_data (info->image, "alt-image"));
+		}
+		
+		/* Dont resize, if the reduced size is equal to the available width */
+		if (gdk_pixbuf_get_width(reduced) == new_width) {
+			return;
+		}
+
+#ifdef HAVE_LIBGNOMEUI_GNOME_THUMBNAIL_H
+		shrunk = gnome_thumbnail_scale_down_pixbuf (original, width, height);
+#else
+		shrunk = gdk_pixbuf_scale_simple(original, width, height, GDK_INTERP_BILINEAR);
+#endif		
+		
+		if (info->size) {
+			gtk_image_set_from_pixbuf (info->image, shrunk);
+			if (info->shown)
+				gtk_widget_show (info->image);
+			else
+				gtk_widget_hide (info->image);
+		} else {
+			g_object_set_data_full (info->image, "alt-image", shrunk, g_object_unref);
+			g_object_unref (reduced);
+		}
+		
+	} else { 
+		/* Time to shrink the image and store it 
+		 * It is also possible that the image size is smaller than the window size, when the window
+		 * is expanded too much.
+		 */
+
+		original = gtk_image_get_pixbuf (info->image);
+		if (!original)
+			return;
+		width = gdk_pixbuf_get_width(original);
+		height = gdk_pixbuf_get_height(original);
+		if (width <= new_width)
+			return;
+			
+		g_object_set_data (info->image, "re-sized", 1);
+
+		/* Check of it is already an altered image */
+		if (!g_object_get_data (info->image, "alt-image"))
+			info->size = 1;
+
+		if (info->size) { /* Ok. We are resizing for the first time */
+			g_object_set_data_full (info->image, "alt-image", original, g_object_unref);
+			g_object_set_data (info->image, "original-width", width);
+			g_object_set_data (info->image, "original-height", height);
+			reduced = gdk_pixbuf_copy (original);				
+			shrunk = gdk_pixbuf_scale_simple (reduced, width, height, GDK_INTERP_BILINEAR);
+			gtk_image_set_from_pixbuf (info->image, shrunk);
+		}
+	}	
+
+}
+
+static gboolean
+efhd_attachment_image (EMFormatHTML *efh, GtkHTMLEmbedded *eb, EMFormatHTMLPObject *pobject)
+{
+	GtkWidget *box;	
+	EMFormatHTMLJob *job;
+	struct _attach_puri *info;
+	GtkTargetEntry drag_types[] = {
+		{ NULL, 0, 0 },
+		{ "text/uri-list", 0, 1 },
+	};
+	char *simple_type;
+	int width = ((GtkWidget *)efh->html)->allocation.width * 95 / 100;
+
+	/* FIXME: Dirty hack to get the part-id */
+	info = em_format_find_puri(efh, g_strdup_printf("attachment%s", &(pobject->classid[5])));
+
+	info->image = gtk_image_new();
+	job = em_format_html_job_new(efh, efhd_write_icon_job, pobject);	
+	job->stream = (CamelStream *)em_image_stream_new((GtkImage *)info->image, pobject->classid, width);
+	em_format_html_job_queue(efh, job);
+
+	box = gtk_event_box_new ();
+	gtk_container_add ((GtkContainer *) box, info->image);
+	gtk_widget_show_all (box);
+	gtk_container_add ((GtkContainer *) eb, box);
+
+	/* By default fit to width*/
+	info->size = 1;
+
+	g_signal_connect (eb, "size_allocate", G_CALLBACK(efhd_image_resize_callback), info);
+	
+	simple_type = camel_content_type_simple (((CamelDataWrapper *)pobject->part)->mime_type);
+	camel_strdown(simple_type);	
+	
+	drag_types[0].target = simple_type;	
+	gtk_drag_source_set(box, GDK_BUTTON1_MASK, drag_types, sizeof(drag_types)/sizeof(drag_types[0]), GDK_ACTION_COPY);
+	
+	g_signal_connect(box, "drag-data-get", G_CALLBACK(efhd_drag_data_get), pobject);
+	g_signal_connect (box, "drag-data-delete", G_CALLBACK(efhd_drag_data_delete), pobject);
+
+	g_signal_connect(box, "button_press_event", G_CALLBACK(efhd_image_popup), info);
+	g_signal_connect(box, "popup_menu", G_CALLBACK(efhd_attachment_popup_menu), info);
+	return TRUE;
+}
+
+void 
+em_format_html_display_handle_image (EMFormatHTML *efh, CamelStream *stream, CamelMimePart *part, EMFormatHandler *info)
+{
+	char *classid;
+	
+	classid = g_strdup_printf("image%s", ((EMFormat *)efh)->part_id->str);
+	em_format_html_add_pobject(efh, sizeof(EMFormatHTMLPObject), classid, part, efhd_attachment_image);	
+
+	camel_stream_printf(stream, "<td><object classid=\"%s\"></object></td>", classid);
 }
 
 static void
Index: em-format-html-display.h
===================================================================
RCS file: /cvs/gnome/evolution/mail/em-format-html-display.h,v
retrieving revision 1.5
diff -u -r1.5 em-format-html-display.h
--- em-format-html-display.h	16 May 2005 07:53:53 -0000	1.5
+++ em-format-html-display.h	23 Jun 2005 09:19:20 -0000
@@ -58,6 +58,8 @@
 void em_format_html_display_zoom_out (EMFormatHTMLDisplay *efhd);
 void em_format_html_display_zoom_reset (EMFormatHTMLDisplay *efhd);
 
+void em_format_html_display_handle_image (EMFormatHTML *efh, CamelStream *stream, CamelMimePart *part, EMFormatHandler *info);
+
 gboolean em_format_html_display_popup_menu (EMFormatHTMLDisplay *efhd);
 
 /* experimental */
Index: em-format-html.c
===================================================================
RCS file: /cvs/gnome/evolution/mail/em-format-html.c,v
retrieving revision 1.78
diff -u -r1.78 em-format-html.c
--- em-format-html.c	19 May 2005 06:06:35 -0000	1.78
+++ em-format-html.c	23 Jun 2005 09:19:20 -0000
@@ -65,6 +65,7 @@
 #include "mail-mt.h"
 
 #include "em-format-html.h"
+#include "em-format-html-display.h"
 #include "em-html-stream.h"
 #include "em-utils.h"
 
@@ -1075,22 +1076,23 @@
 	camel_stream_printf(stream, "<img hspace=10 vspace=10 src=\"%s\">", puri->cid);
 }
 
+
 static EMFormatHandler type_builtin_table[] = {
-	{ "image/gif", (EMFormatFunc)efh_image },
-	{ "image/jpeg", (EMFormatFunc)efh_image },
-	{ "image/png", (EMFormatFunc)efh_image },
-	{ "image/x-png", (EMFormatFunc)efh_image },
-	{ "image/tiff", (EMFormatFunc)efh_image },
-	{ "image/x-bmp", (EMFormatFunc)efh_image },
-	{ "image/bmp", (EMFormatFunc)efh_image },
-	{ "image/svg", (EMFormatFunc)efh_image },
-	{ "image/x-cmu-raster", (EMFormatFunc)efh_image },
-	{ "image/x-ico", (EMFormatFunc)efh_image },
-	{ "image/x-portable-anymap", (EMFormatFunc)efh_image },
-	{ "image/x-portable-bitmap", (EMFormatFunc)efh_image },
-	{ "image/x-portable-graymap", (EMFormatFunc)efh_image },
-	{ "image/x-portable-pixmap", (EMFormatFunc)efh_image },
-	{ "image/x-xpixmap", (EMFormatFunc)efh_image },
+	{ "image/gif", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/jpeg", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/png", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-png", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/tiff", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-bmp", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/bmp", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/svg", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-cmu-raster", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-ico", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-portable-anymap", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-portable-bitmap", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-portable-graymap", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-portable-pixmap", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/x-xpixmap", (EMFormatFunc)em_format_html_display_handle_image },
 	{ "text/enriched", (EMFormatFunc)efh_text_enriched },
 	{ "text/plain", (EMFormatFunc)efh_text_plain },
 	{ "text/html", (EMFormatFunc)efh_text_html },
@@ -1104,8 +1106,8 @@
 	   that some idiot mailer writers out there decide to pull out
 	   of their proverbials at random. */
 
-	{ "image/jpg", (EMFormatFunc)efh_image },
-	{ "image/pjpeg", (EMFormatFunc)efh_image },
+	{ "image/jpg", (EMFormatFunc)em_format_html_display_handle_image },
+	{ "image/pjpeg", (EMFormatFunc)em_format_html_display_handle_image },
 
 	/* special internal types */