moving trunk for module inkscape

(bzr r1)

1 files changed, 1200 insertions, 0 deletions

diff --git a/src/sp-image.cpp b/src/sp-image.cpp
new file mode 100644
index 000000000..869981567
--- /dev/null
+++ b/src/sp-image.cpp
@@ -0,0 +1,1200 @@
+#define __SP_IMAGE_C__
+
+/*
+ * SVG <image> implementation
+ *
+ * Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   Edward Flick (EAF)
+ *
+ * Copyright (C) 1999-2005 Authors
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+#include <libnr/nr-matrix-fns.h>
+
+//#define GDK_PIXBUF_ENABLE_BACKEND 1
+//#include <gdk-pixbuf/gdk-pixbuf-io.h>
+#include "display/nr-arena-image.h"
+
+//Added for preserveAspectRatio support -- EAF
+#include "enums.h"
+#include "attributes.h"
+
+#include "print.h"
+#include "brokenimage.xpm"
+#include "document.h"
+#include "sp-image.h"
+#include <glibmm/i18n.h>
+#include "xml/quote.h"
+#include <xml/repr.h>
+
+#include "io/sys.h"
+#include <png.h>
+
+/*
+ * SPImage
+ */
+
+
+static void sp_image_class_init (SPImageClass * klass);
+static void sp_image_init (SPImage * image);
+
+static void sp_image_build (SPObject * object, SPDocument * document, Inkscape::XML::Node * repr);
+static void sp_image_release (SPObject * object);
+static void sp_image_set (SPObject *object, unsigned int key, const gchar *value);
+static void sp_image_update (SPObject *object, SPCtx *ctx, unsigned int flags);
+static Inkscape::XML::Node *sp_image_write (SPObject *object, Inkscape::XML::Node *repr, guint flags);
+
+static void sp_image_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const flags);
+static void sp_image_print (SPItem * item, SPPrintContext *ctx);
+static gchar * sp_image_description (SPItem * item);
+static void sp_image_snappoints(SPItem const *item, SnapPointsIter p);
+static NRArenaItem *sp_image_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags);
+static NR::Matrix sp_image_set_transform (SPItem *item, NR::Matrix const &xform);
+
+GdkPixbuf * sp_image_repr_read_image (Inkscape::XML::Node * repr);
+static GdkPixbuf *sp_image_pixbuf_force_rgba (GdkPixbuf * pixbuf);
+static void sp_image_update_canvas_image (SPImage *image);
+static GdkPixbuf * sp_image_repr_read_dataURI (const gchar * uri_data);
+static GdkPixbuf * sp_image_repr_read_b64 (const gchar * uri_data);
+
+static SPItemClass *parent_class;
+
+
+extern "C"
+{
+    void user_read_data( png_structp png_ptr, png_bytep data, png_size_t length );
+    void user_write_data( png_structp png_ptr, png_bytep data, png_size_t length );
+    void user_flush_data( png_structp png_ptr );
+
+}
+
+namespace Inkscape {
+namespace IO {
+
+class PushPull
+{
+public:
+    gboolean    first;
+    FILE*       fp;
+    guchar*     scratch;
+    gsize       size;
+    gsize       used;
+    gsize       offset;
+    GdkPixbufLoader *loader;
+
+    PushPull() : first(TRUE),
+                 fp(0),
+                 scratch(0),
+                 size(0),
+                 used(0),
+                 offset(0),
+                 loader(0) {};
+
+    gboolean readMore()
+    {
+        gboolean good = FALSE;
+        if ( offset )
+        {
+            g_memmove( scratch, scratch + offset, used - offset );
+            used -= offset;
+            offset = 0;
+        }
+        if ( used < size )
+        {
+            gsize space = size - used;
+            gsize got = fread( scratch + used, 1, space, fp );
+            if ( got )
+            {
+                if ( loader )
+                {
+                    GError *err = NULL;
+                    //g_message( " __read %d bytes", (int)got );
+                    if ( !gdk_pixbuf_loader_write( loader, scratch + used, got, &err ) )
+                    {
+                        //g_message("_error writing pixbuf data"); 
+                    }
+                }
+
+                used += got;
+                good = TRUE;
+            }
+            else
+            {
+                good = FALSE;
+            }
+        }
+        return good;
+    }
+
+    gsize available() const
+    {
+        return (used - offset);
+    }
+
+    gsize readOut( gpointer data, gsize length )
+    {
+        gsize giving = available();
+        if ( length < giving )
+        {
+            giving = length;
+        }
+        g_memmove( data, scratch + offset, giving );
+        offset += giving;
+        if ( offset >= used )
+        {
+            offset = 0;
+            used = 0;
+        }
+        return giving;
+    }
+
+    void clear()
+    {
+        offset = 0;
+        used = 0;
+    }
+
+private:
+    PushPull& operator = (const PushPull& other);
+    PushPull(const PushPull& other);
+};
+
+void user_read_data( png_structp png_ptr, png_bytep data, png_size_t length )
+{
+//    g_message( "user_read_data(%d)", length );
+
+    PushPull* youme = (PushPull*)png_get_io_ptr(png_ptr);
+
+    gsize filled = 0;
+    gboolean canRead = TRUE;
+
+    while ( filled < length && canRead )
+    {
+        gsize some = youme->readOut( data + filled, length - filled );
+        filled += some;
+        if ( filled < length )
+        {
+            canRead &= youme->readMore();
+        }
+    }
+//    g_message("things out");
+}
+
+void user_write_data( png_structp png_ptr, png_bytep data, png_size_t length )
+{
+    //g_message( "user_write_data(%d)", length );
+}
+
+void user_flush_data( png_structp png_ptr )
+{
+    //g_message( "user_flush_data" );
+}
+
+GdkPixbuf*  pixbuf_new_from_file( const char *filename, GError **error )
+{
+    GdkPixbuf* buf = NULL;
+    PushPull youme;
+    gint dpiX = 0;
+    gint dpiY = 0;
+
+    //buf = gdk_pixbuf_new_from_file( filename, error );
+    dump_fopen_call( filename, "pixbuf_new_from_file" );
+    FILE* fp = fopen_utf8name( filename, "r" );
+    if ( fp )
+    {
+        GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
+        if ( loader )
+        {
+            GError *err = NULL;
+
+            // short buffer
+            guchar scratch[1024];
+            gboolean latter = FALSE;
+            gboolean isPng = FALSE;
+            png_structp pngPtr = NULL;
+            png_infop infoPtr = NULL;
+            //png_infop endPtr = NULL;
+
+            youme.fp = fp;
+            youme.scratch = scratch;
+            youme.size = sizeof(scratch);
+            youme.used = 0;
+            youme.offset = 0;
+            youme.loader = loader;
+
+            while ( !feof(fp) )
+            {
+                if ( youme.readMore() )
+                {
+                    if ( youme.first )
+                    {
+                        //g_message( "First data chunk" );
+                        youme.first = FALSE;
+                        isPng = !png_sig_cmp( scratch + youme.offset, 0, youme.available() );
+                        //g_message( "  png? %s", (isPng ? "Yes":"No") );
+                        if ( isPng )
+                        {
+                            pngPtr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
+                                                             NULL,//(png_voidp)user_error_ptr,
+                                                             NULL,//user_error_fn,
+                                                             NULL//user_warning_fn
+                                );
+                            if ( pngPtr )
+                            {
+                                infoPtr = png_create_info_struct( pngPtr );
+                                //endPtr = png_create_info_struct( pngPtr );
+
+                                png_set_read_fn( pngPtr, &youme, user_read_data );
+                                //g_message( "In" );
+
+                                //png_read_info( pngPtr, infoPtr );
+                                png_read_png( pngPtr, infoPtr, PNG_TRANSFORM_IDENTITY, NULL );
+
+                                //g_message("out");
+
+                                //png_read_end(pngPtr, endPtr);
+
+                                /*
+                                if ( png_get_valid( pngPtr, infoPtr, PNG_INFO_pHYs ) )
+                                {
+                                    g_message("pHYs chunk now valid" );
+                                }
+                                if ( png_get_valid( pngPtr, infoPtr, PNG_INFO_sCAL ) )
+                                {
+                                    g_message("sCAL chunk now valid" );
+                                }
+                                */
+
+                                png_uint_32 res_x = 0;
+                                png_uint_32 res_y = 0;
+                                int unit_type = 0;
+                                if ( png_get_pHYs( pngPtr, infoPtr, &res_x, &res_y, &unit_type) )
+                                {
+//                                     g_message( "pHYs yes (%d, %d) %d (%s)", (int)res_x, (int)res_y, unit_type,
+//                                                (unit_type == 1? "per meter" : "unknown")
+//                                         );
+
+//                                     g_message( "    dpi: (%d, %d)",
+//                                                (int)(0.5 + ((double)res_x)/39.37),
+//                                                (int)(0.5 + ((double)res_y)/39.37) );
+                                    if ( unit_type == PNG_RESOLUTION_METER )
+                                    {
+                                        // TODO come up with a more accurate DPI setting
+                                        dpiX = (int)(0.5 + ((double)res_x)/39.37);
+                                        dpiY = (int)(0.5 + ((double)res_y)/39.37);
+                                    }
+                                }
+                                else
+                                {
+//                                     g_message( "pHYs no" );
+                                }
+
+/*
+                                double width = 0;
+                                double height = 0;
+                                int unit = 0;
+                                if ( png_get_sCAL(pngPtr, infoPtr, &unit, &width, &height) )
+                                {
+                                    gchar* vals[] = {
+                                        "unknown", // PNG_SCALE_UNKNOWN
+                                        "meter", // PNG_SCALE_METER
+                                        "radian", // PNG_SCALE_RADIAN
+                                        "last", // 
+                                        NULL
+                                    };
+
+                                    g_message( "sCAL: (%f, %f) %d (%s)",
+                                               width, height, unit,
+                                               ((unit >= 0 && unit < 3) ? vals[unit]:"???")
+                                        );
+                                }
+*/
+
+                                // now clean it up.
+                                png_destroy_read_struct( &pngPtr, &infoPtr, NULL );//&endPtr );
+                            }
+                            else
+                            {
+                                g_message("Error when creating PNG read struct");
+                            }
+                        }
+                    }
+                    else if ( !latter )
+                    {
+                        latter = TRUE;
+                        //g_message("  READing latter");
+                    }
+                    // Now clear out the buffer so we can read more.
+                    // (dumping out unused)
+                    youme.clear();
+                }
+            }
+
+            gboolean ok = gdk_pixbuf_loader_close(loader, &err);
+            if ( ok )
+            {
+                buf = gdk_pixbuf_loader_get_pixbuf( loader );
+                if ( buf )
+                {
+                    g_object_ref(buf);
+
+                    if ( dpiX )
+                    {
+                        gchar *tmp = g_strdup_printf( "%d", dpiX );
+                        if ( tmp )
+                        {
+                            //gdk_pixbuf_set_option( buf, "Inkscape::DpiX", tmp );
+                            g_free( tmp );
+                        }
+                    }
+                    if ( dpiY )
+                    {
+                        gchar *tmp = g_strdup_printf( "%d", dpiY );
+                        if ( tmp )
+                        {
+                            //gdk_pixbuf_set_option( buf, "Inkscape::DpiY", tmp );
+                            g_free( tmp );
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // do something
+                g_message("error loading pixbuf at close");
+            }
+
+            g_object_unref(loader);
+        }
+        else
+        {
+            g_message("error when creating pixbuf loader");
+        }
+        fclose( fp );
+        fp = NULL;
+    }
+    else
+    {
+        g_warning ("unable to open file: %s", filename);
+    }
+
+/*
+    if ( buf )
+    {
+        const gchar* bloop = gdk_pixbuf_get_option( buf, "Inkscape::DpiX" );
+        if ( bloop )
+        {
+            g_message("DPI X is [%s]", bloop);
+        }
+        bloop = gdk_pixbuf_get_option( buf, "Inkscape::DpiY" );
+        if ( bloop )
+        {
+            g_message("DPI Y is [%s]", bloop);
+        }
+    }
+*/
+
+    return buf;
+}
+
+}
+}
+
+GType
+sp_image_get_type (void)
+{
+	static GType image_type = 0;
+	if (!image_type) {
+		GTypeInfo image_info = {
+			sizeof (SPImageClass),
+			NULL,	/* base_init */
+			NULL,	/* base_finalize */
+			(GClassInitFunc) sp_image_class_init,
+			NULL,	/* class_finalize */
+			NULL,	/* class_data */
+			sizeof (SPImage),
+			16,	/* n_preallocs */
+			(GInstanceInitFunc) sp_image_init,
+			NULL,	/* value_table */
+		};
+		image_type = g_type_register_static (sp_item_get_type (), "SPImage", &image_info, (GTypeFlags)0);
+	}
+	return image_type;
+}
+
+static void
+sp_image_class_init (SPImageClass * klass)
+{
+	GObjectClass * gobject_class;
+	SPObjectClass * sp_object_class;
+	SPItemClass * item_class;
+
+	gobject_class = (GObjectClass *) klass;
+	sp_object_class = (SPObjectClass *) klass;
+	item_class = (SPItemClass *) klass;
+
+	parent_class = (SPItemClass*)g_type_class_ref (sp_item_get_type ());
+
+	sp_object_class->build = sp_image_build;
+	sp_object_class->release = sp_image_release;
+	sp_object_class->set = sp_image_set;
+	sp_object_class->update = sp_image_update;
+	sp_object_class->write = sp_image_write;
+
+	item_class->bbox = sp_image_bbox;
+	item_class->print = sp_image_print;
+	item_class->description = sp_image_description;
+	item_class->show = sp_image_show;
+	item_class->snappoints = sp_image_snappoints;
+	item_class->set_transform = sp_image_set_transform;
+}
+
+static void
+sp_image_init (SPImage *image)
+{
+	image->x.unset();
+	image->y.unset();
+	image->width.unset();
+	image->height.unset();
+	image->aspect_align = SP_ASPECT_NONE;
+}
+
+static void
+sp_image_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+{
+	if (((SPObjectClass *) parent_class)->build)
+		((SPObjectClass *) parent_class)->build (object, document, repr);
+
+	sp_object_read_attr (object, "xlink:href");
+	sp_object_read_attr (object, "x");
+	sp_object_read_attr (object, "y");
+	sp_object_read_attr (object, "width");
+	sp_object_read_attr (object, "height");
+	sp_object_read_attr (object, "preserveAspectRatio");
+
+	/* Register */
+	sp_document_add_resource (document, "image", object);
+}
+
+static void
+sp_image_release (SPObject *object)
+{
+	SPImage *image;
+
+	image = SP_IMAGE (object);
+
+	if (SP_OBJECT_DOCUMENT (object)) {
+		/* Unregister ourselves */
+		sp_document_remove_resource (SP_OBJECT_DOCUMENT (object), "image", SP_OBJECT (object));
+	}
+
+	if (image->href) {
+		g_free (image->href);
+		image->href = NULL;
+	}
+
+	if (image->pixbuf) {
+		gdk_pixbuf_unref (image->pixbuf);
+		image->pixbuf = NULL;
+	}
+
+	if (((SPObjectClass *) parent_class)->release)
+		((SPObjectClass *) parent_class)->release (object);
+}
+
+static void
+sp_image_set (SPObject *object, unsigned int key, const gchar *value)
+{
+	SPImage *image;
+
+	image = SP_IMAGE (object);
+
+	switch (key) {
+	case SP_ATTR_XLINK_HREF:
+		g_free (image->href);
+		image->href = (value) ? g_strdup (value) : NULL;
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_IMAGE_HREF_MODIFIED_FLAG);
+		break;
+	case SP_ATTR_X:
+		if (!image->x.readAbsolute(value)) {
+		    /* fixme: em, ex, % are probably valid, but require special treatment (Lauris) */
+			image->x.unset();
+		}
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+		break;
+	case SP_ATTR_Y:
+		if (!image->y.readAbsolute(value)) {
+		    /* fixme: em, ex, % are probably valid, but require special treatment (Lauris) */
+			image->y.unset();
+		}
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+		break;
+	case SP_ATTR_WIDTH:
+		if (!image->width.readAbsolute(value)) {
+		    /* fixme: em, ex, % are probably valid, but require special treatment (Lauris) */
+			image->width.unset();
+		}
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+		break;
+	case SP_ATTR_HEIGHT:
+		if (!image->height.readAbsolute(value)) {
+		    /* fixme: em, ex, % are probably valid, but require special treatment (Lauris) */
+			image->height.unset();
+		}
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+		break;
+	case SP_ATTR_PRESERVEASPECTRATIO:
+		/* Do setup before, so we can use break to escape */
+		image->aspect_align = SP_ASPECT_NONE;
+		image->aspect_clip = SP_ASPECT_MEET;
+		object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG);
+		if (value) {
+			int len;
+			gchar c[256];
+			const gchar *p, *e;
+			unsigned int align, clip;
+			p = value;
+			while (*p && *p == 32) p += 1;
+			if (!*p) break;
+			e = p;
+			while (*e && *e != 32) e += 1;
+			len = e - p;
+			if (len > 8) break;
+			memcpy (c, value, len);
+			c[len] = 0;
+			/* Now the actual part */
+			if (!strcmp (c, "none")) {
+				align = SP_ASPECT_NONE;
+			} else if (!strcmp (c, "xMinYMin")) {
+				align = SP_ASPECT_XMIN_YMIN;
+			} else if (!strcmp (c, "xMidYMin")) {
+				align = SP_ASPECT_XMID_YMIN;
+			} else if (!strcmp (c, "xMaxYMin")) {
+				align = SP_ASPECT_XMAX_YMIN;
+			} else if (!strcmp (c, "xMinYMid")) {
+				align = SP_ASPECT_XMIN_YMID;
+			} else if (!strcmp (c, "xMidYMid")) {
+				align = SP_ASPECT_XMID_YMID;
+			} else if (!strcmp (c, "xMaxYMid")) {
+				align = SP_ASPECT_XMAX_YMID;
+			} else if (!strcmp (c, "xMinYMax")) {
+				align = SP_ASPECT_XMIN_YMAX;
+			} else if (!strcmp (c, "xMidYMax")) {
+				align = SP_ASPECT_XMID_YMAX;
+			} else if (!strcmp (c, "xMaxYMax")) {
+				align = SP_ASPECT_XMAX_YMAX;
+			} else {
+				break;
+			}
+			clip = SP_ASPECT_MEET;
+			while (*e && *e == 32) e += 1;
+			if (e) {
+				if (!strcmp (e, "meet")) {
+					clip = SP_ASPECT_MEET;
+				} else if (!strcmp (e, "slice")) {
+					clip = SP_ASPECT_SLICE;
+				} else {
+					break;
+				}
+			}
+			image->aspect_align = align;
+			image->aspect_clip = clip;
+		}
+		break;
+	default:
+		if (((SPObjectClass *) (parent_class))->set)
+			((SPObjectClass *) (parent_class))->set (object, key, value);
+		break;
+	}
+}
+
+static void
+sp_image_update (SPObject *object, SPCtx *ctx, unsigned int flags)
+{
+	SPImage *image;
+
+	image = (SPImage *) object;
+
+	if (((SPObjectClass *) (parent_class))->update)
+		((SPObjectClass *) (parent_class))->update (object, ctx, flags);
+
+	if (flags & SP_IMAGE_HREF_MODIFIED_FLAG) {
+		if (image->pixbuf) {
+			gdk_pixbuf_unref (image->pixbuf);
+			image->pixbuf = NULL;
+		}
+		if (image->href) {
+			GdkPixbuf *pixbuf;
+			pixbuf = sp_image_repr_read_image (object->repr);
+			if (pixbuf) {
+				pixbuf = sp_image_pixbuf_force_rgba (pixbuf);
+				image->pixbuf = pixbuf;
+			}
+		}
+	}
+	// preserveAspectRatio calculate bounds / clipping rectangle -- EAF
+	if (image->pixbuf && (image->aspect_align != SP_ASPECT_NONE)) {
+		        int imagewidth, imageheight;
+			double x,y;
+
+		        imagewidth = gdk_pixbuf_get_width (image->pixbuf);
+		        imageheight = gdk_pixbuf_get_height (image->pixbuf);
+
+			switch (image->aspect_align) {
+			case SP_ASPECT_XMIN_YMIN:
+				x = 0.0;
+				y = 0.0;
+				break;
+			case SP_ASPECT_XMID_YMIN:
+				x = 0.5;
+				y = 0.0;
+				break;
+			case SP_ASPECT_XMAX_YMIN:
+				x = 1.0;
+				y = 0.0;
+				break;
+			case SP_ASPECT_XMIN_YMID:
+				x = 0.0;
+				y = 0.5;
+				break;
+			case SP_ASPECT_XMID_YMID:
+				x = 0.5;
+				y = 0.5;
+				break;
+			case SP_ASPECT_XMAX_YMID:
+				x = 1.0;
+				y = 0.5;
+				break;
+			case SP_ASPECT_XMIN_YMAX:
+				x = 0.0;
+				y = 1.0;
+				break;
+			case SP_ASPECT_XMID_YMAX:
+				x = 0.5;
+				y = 1.0;
+				break;
+			case SP_ASPECT_XMAX_YMAX:
+				x = 1.0;
+				y = 1.0;
+				break;
+			default:
+				x = 0.0;
+				y = 0.0;
+				break;
+			}
+
+			if (image->aspect_clip == SP_ASPECT_SLICE) {
+				image->viewx = image->x.computed;
+				image->viewy = image->y.computed;
+				image->viewwidth = image->width.computed;
+				image->viewheight = image->height.computed;
+				if ((imagewidth*image->height.computed)>(image->width.computed*imageheight)) {
+					// Pixels aspect is wider than bounding box
+					image->trimheight = imageheight;
+					image->trimwidth = static_cast<int>(static_cast<double>(imageheight) * image->width.computed / image->height.computed);
+					image->trimy = 0;
+					image->trimx = static_cast<int>(static_cast<double>(imagewidth - image->trimwidth) * x);
+				} else {
+					// Pixels aspect is taller than bounding box
+					image->trimwidth = imagewidth;
+					image->trimheight = static_cast<int>(static_cast<double>(imagewidth) * image->height.computed / image->width.computed);
+					image->trimx = 0;
+					image->trimy = static_cast<int>(static_cast<double>(imageheight - image->trimheight) * y);
+				}
+			} else {
+				// Otherwise, assume SP_ASPECT_MEET
+				image->trimx = 0;
+				image->trimy = 0;
+				image->trimwidth = imagewidth;
+				image->trimheight = imageheight;
+				if ((imagewidth*image->height.computed)>(image->width.computed*imageheight)) {
+					// Pixels aspect is wider than bounding boz
+					image->viewwidth = image->width.computed;
+					image->viewheight = image->viewwidth * imageheight / imagewidth;
+					image->viewx=image->x.computed;
+					image->viewy=(image->height.computed - image->viewheight) * y + image->y.computed;
+				} else {
+					// Pixels aspect is taller than bounding box
+					image->viewheight = image->height.computed;
+					image->viewwidth = image->viewheight * imagewidth / imageheight;
+					image->viewy=image->y.computed;
+					image->viewx=(image->width.computed - image->viewwidth) * x + image->x.computed;
+				}
+			}
+	}
+	
+	sp_image_update_canvas_image ((SPImage *) object);
+}
+
+static Inkscape::XML::Node *
+sp_image_write (SPObject *object, Inkscape::XML::Node *repr, guint flags)
+{
+	SPImage *image;
+
+	image = SP_IMAGE (object);
+
+	if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+		repr = sp_repr_new ("svg:image");
+	}
+
+	repr->setAttribute("xlink:href", image->href);
+	/* fixme: Reset attribute if needed (Lauris) */
+	if (image->x._set) sp_repr_set_svg_double(repr, "x", image->x.computed);
+	if (image->y._set) sp_repr_set_svg_double(repr, "y", image->y.computed);
+	if (image->width._set) sp_repr_set_svg_double(repr, "width", image->width.computed);
+	if (image->height._set) sp_repr_set_svg_double(repr, "height", image->height.computed);
+	repr->setAttribute("preserveAspectRatio", object->repr->attribute("preserveAspectRatio"));
+
+	if (((SPObjectClass *) (parent_class))->write)
+		((SPObjectClass *) (parent_class))->write (object, repr, flags);
+
+	return repr;
+}
+
+static void
+sp_image_bbox(SPItem const *item, NRRect *bbox, NR::Matrix const &transform, unsigned const flags)
+{
+	SPImage const &image = *SP_IMAGE(item);
+
+	if ((image.width.computed > 0.0) && (image.height.computed > 0.0)) {
+		double const x0 = image.x.computed;
+		double const y0 = image.y.computed;
+		double const x1 = x0 + image.width.computed;
+		double const y1 = y0 + image.height.computed;
+
+		nr_rect_union_pt(bbox, NR::Point(x0, y0) * transform);
+		nr_rect_union_pt(bbox, NR::Point(x1, y0) * transform);
+		nr_rect_union_pt(bbox, NR::Point(x1, y1) * transform);
+		nr_rect_union_pt(bbox, NR::Point(x0, y1) * transform);
+	}
+}
+
+static void
+sp_image_print (SPItem *item, SPPrintContext *ctx)
+{
+	SPImage *image;
+	NRMatrix tp, ti, s, t;
+	guchar *px;
+	int w, h, rs, pixskip;
+
+	image = SP_IMAGE (item);
+
+	if (!image->pixbuf) return;
+	if ((image->width.computed <= 0.0) || (image->height.computed <= 0.0)) return;
+	
+	px = gdk_pixbuf_get_pixels (image->pixbuf);
+	w = gdk_pixbuf_get_width (image->pixbuf);
+	h = gdk_pixbuf_get_height (image->pixbuf);
+	rs = gdk_pixbuf_get_rowstride (image->pixbuf);
+	pixskip = gdk_pixbuf_get_n_channels (image->pixbuf) * gdk_pixbuf_get_bits_per_sample (image->pixbuf) / 8;
+       
+	if (image->aspect_align == SP_ASPECT_NONE) {
+		/* fixme: (Lauris) */
+		nr_matrix_set_translate (&tp, image->x.computed, image->y.computed);
+		nr_matrix_set_scale (&s, image->width.computed, -image->height.computed);
+		nr_matrix_set_translate (&ti, 0.0, -1.0);
+	} else { // preserveAspectRatio
+		nr_matrix_set_translate (&tp, image->viewx, image->viewy);
+		nr_matrix_set_scale (&s, image->viewwidth, -image->viewheight);
+		nr_matrix_set_translate (&ti, 0.0, -1.0);
+	}
+
+	nr_matrix_multiply (&t, &s, &tp);
+	nr_matrix_multiply (&t, &ti, &t);
+
+	if (image->aspect_align == SP_ASPECT_NONE)
+		sp_print_image_R8G8B8A8_N (ctx, px, w, h, rs, &t, SP_OBJECT_STYLE (item));
+	else // preserveAspectRatio
+		sp_print_image_R8G8B8A8_N (ctx, px + image->trimx*pixskip + image->trimy*rs, image->trimwidth, image->trimheight, rs, &t, SP_OBJECT_STYLE (item));
+}
+
+static gchar *
+sp_image_description(SPItem *item)
+{
+	SPImage *image = SP_IMAGE(item);
+	char *href_desc;
+        if (image->href) {
+            href_desc = (strncmp(image->href, "data:", 5) == 0) 
+                ? g_strdup(_("embedded"))
+                : xml_quote_strdup(image->href);
+        } else {
+            g_warning("Attempting to call strncmp() with a null pointer.");
+            href_desc = g_strdup(_("(null_pointer)")); // we call g_free() on href_desc
+        }                
+
+	char *ret = ( image->pixbuf == NULL
+		      ? g_strdup_printf(_("<b>Image with bad reference</b>: %s"), href_desc)
+		      : g_strdup_printf(_("<b>Image</b> %d &#215; %d: %s"),
+					gdk_pixbuf_get_width(image->pixbuf),
+					gdk_pixbuf_get_height(image->pixbuf),
+					href_desc) );
+	g_free(href_desc);
+	return ret;
+}
+
+static NRArenaItem *
+sp_image_show (SPItem *item, NRArena *arena, unsigned int key, unsigned int flags)
+{
+	int pixskip, rs;
+	SPImage * image;
+	NRArenaItem *ai;
+
+	image = (SPImage *) item;
+
+	ai = NRArenaImage::create(arena);
+
+	if (image->pixbuf) {
+	        pixskip = gdk_pixbuf_get_n_channels (image->pixbuf) * gdk_pixbuf_get_bits_per_sample (image->pixbuf) / 8;
+		rs = gdk_pixbuf_get_rowstride (image->pixbuf);
+	        if (image->aspect_align == SP_ASPECT_NONE)
+			nr_arena_image_set_pixels (NR_ARENA_IMAGE (ai),
+					   gdk_pixbuf_get_pixels (image->pixbuf),
+					   gdk_pixbuf_get_width (image->pixbuf),
+					   gdk_pixbuf_get_height (image->pixbuf),
+					   rs);
+		else // preserveAspectRatio
+			nr_arena_image_set_pixels (NR_ARENA_IMAGE (ai),
+					   gdk_pixbuf_get_pixels (image->pixbuf) + image->trimx*pixskip + image->trimy*rs,
+					   image->trimwidth,
+					   image->trimheight,
+					   rs);
+	} else {
+		nr_arena_image_set_pixels (NR_ARENA_IMAGE (ai), NULL, 0, 0, 0);
+	}
+	if (image->aspect_align == SP_ASPECT_NONE)
+		nr_arena_image_set_geometry (NR_ARENA_IMAGE (ai), image->x.computed, image->y.computed, image->width.computed, image->height.computed);
+	else // preserveAspectRatio
+		nr_arena_image_set_geometry (NR_ARENA_IMAGE (ai), image->viewx, image->viewy, image->viewwidth, image->viewheight);
+
+	return ai;
+}
+
+/*
+ * utility function to try loading image from href
+ *
+ * docbase/relative_src
+ * absolute_src
+ *
+ */
+
+GdkPixbuf *
+sp_image_repr_read_image (Inkscape::XML::Node * repr)
+{
+	const gchar * filename, * docbase;
+	gchar * fullname;
+	GdkPixbuf * pixbuf;
+
+	filename = repr->attribute("xlink:href");
+	if (filename == NULL) filename = repr->attribute("href"); /* FIXME */
+	if (filename != NULL) {
+		if (strncmp (filename,"file:",5) == 0) {
+			fullname = g_filename_from_uri(filename, NULL, NULL);
+			if (fullname) {
+				// TODO check this. Was doing a UTF-8 to filename conversion here.
+				pixbuf = Inkscape::IO::pixbuf_new_from_file (fullname, NULL);
+				if (pixbuf != NULL) return pixbuf;
+			}
+		} else if (strncmp (filename,"data:",5) == 0) {
+			/* data URI - embedded image */
+			filename += 5;
+			pixbuf = sp_image_repr_read_dataURI (filename);
+			if (pixbuf != NULL) return pixbuf;
+		} else if (!g_path_is_absolute (filename)) {
+			/* try to load from relative pos */
+			docbase = sp_repr_document_root (sp_repr_document (repr))->attribute("sodipodi:docbase");
+			if (!docbase) docbase = ".";
+			fullname = g_build_filename(docbase, filename, NULL);
+			pixbuf = Inkscape::IO::pixbuf_new_from_file( fullname, NULL );
+			g_free (fullname);
+			if (pixbuf != NULL) return pixbuf;
+		} else {
+			/* try absolute filename */
+			pixbuf = Inkscape::IO::pixbuf_new_from_file( filename, NULL );
+			if (pixbuf != NULL) return pixbuf;
+		}
+	}
+	/* at last try to load from sp absolute path name */
+	filename = repr->attribute("sodipodi:absref");
+	if (filename != NULL) {
+		pixbuf = Inkscape::IO::pixbuf_new_from_file( filename, NULL );
+		if (pixbuf != NULL) return pixbuf;
+	}
+	/* Nope: We do not find any valid pixmap file :-( */
+	pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) brokenimage_xpm);
+
+	/* It should be included xpm, so if it still does not does load, */
+	/* our libraries are broken */
+	g_assert (pixbuf != NULL);
+
+	return pixbuf;
+}
+
+static GdkPixbuf *
+sp_image_pixbuf_force_rgba (GdkPixbuf * pixbuf)
+{
+	GdkPixbuf * newbuf;
+
+	if (gdk_pixbuf_get_has_alpha (pixbuf)) return pixbuf;
+
+	newbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+	gdk_pixbuf_unref (pixbuf);
+
+	return newbuf;
+}
+
+/* We assert that realpixbuf is either NULL or identical size to pixbuf */
+
+static void
+sp_image_update_canvas_image (SPImage *image)
+{
+	int rs, pixskip;
+	SPItem *item;
+	SPItemView *v;
+
+	item = SP_ITEM (image);
+
+	if (image->pixbuf) {
+		/* fixme: We are slightly violating spec here (Lauris) */
+		if (!image->width._set) {
+			image->width.computed = gdk_pixbuf_get_width (image->pixbuf);
+		}
+		if (!image->height._set) {
+			image->height.computed = gdk_pixbuf_get_height (image->pixbuf);
+		}
+	}
+
+	for (v = item->display; v != NULL; v = v->next) {
+	        pixskip = gdk_pixbuf_get_n_channels (image->pixbuf) * gdk_pixbuf_get_bits_per_sample (image->pixbuf) / 8;
+		rs = gdk_pixbuf_get_rowstride (image->pixbuf);
+		if (image->aspect_align == SP_ASPECT_NONE) {
+			nr_arena_image_set_pixels (NR_ARENA_IMAGE (v->arenaitem),
+					   gdk_pixbuf_get_pixels (image->pixbuf),
+					   gdk_pixbuf_get_width (image->pixbuf),
+					   gdk_pixbuf_get_height (image->pixbuf),
+					   rs);
+			nr_arena_image_set_geometry (NR_ARENA_IMAGE (v->arenaitem),
+					     image->x.computed, image->y.computed,
+					     image->width.computed, image->height.computed);
+		} else { // preserveAspectRatio
+			nr_arena_image_set_pixels (NR_ARENA_IMAGE (v->arenaitem),
+					   gdk_pixbuf_get_pixels (image->pixbuf) + image->trimx*pixskip + image->trimy*rs,
+					   image->trimwidth,
+					   image->trimheight,
+					   rs);
+			nr_arena_image_set_geometry (NR_ARENA_IMAGE (v->arenaitem),
+					     image->viewx, image->viewy,
+					     image->viewwidth, image->viewheight);
+		}
+	}
+}
+
+static void sp_image_snappoints(SPItem const *item, SnapPointsIter p)
+{
+     if (((SPItemClass *) parent_class)->snappoints) {
+         ((SPItemClass *) parent_class)->snappoints (item, p);
+     }
+}
+
+/*
+ * Initially we'll do:
+ * Transform x, y, set x, y, clear translation
+ */
+
+static NR::Matrix
+sp_image_set_transform(SPItem *item, NR::Matrix const &xform)
+{
+	SPImage *image = SP_IMAGE(item);
+
+	/* Calculate position in parent coords. */
+	NR::Point pos( NR::Point(image->x.computed, image->y.computed) * xform );
+
+	/* This function takes care of translation and scaling, we return whatever parts we can't
+	   handle. */
+	NR::Matrix ret(NR::transform(xform));
+	NR::Point const scale(hypot(ret[0], ret[1]),
+			      hypot(ret[2], ret[3]));
+	if ( scale[NR::X] > 1e-9 ) {
+		ret[0] /= scale[NR::X];
+		ret[1] /= scale[NR::X];
+	} else {
+		ret[0] = 1.0;
+		ret[1] = 0.0;
+	}
+	if ( scale[NR::Y] > 1e-9 ) {
+		ret[2] /= scale[NR::Y];
+		ret[3] /= scale[NR::Y];
+	} else {
+		ret[2] = 0.0;
+		ret[3] = 1.0;
+	}
+
+	image->width = image->width.computed * scale[NR::X];
+	image->height = image->height.computed * scale[NR::Y];
+
+	/* Find position in item coords */
+	pos = pos * ret.inverse();
+	image->x = pos[NR::X];
+	image->y = pos[NR::Y];
+
+	item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+
+	return ret;
+}
+
+static GdkPixbuf *
+sp_image_repr_read_dataURI (const gchar * uri_data)
+{	GdkPixbuf * pixbuf = NULL;
+
+	gint data_is_image = 0;
+	gint data_is_base64 = 0;
+
+	const gchar * data = uri_data;
+
+	while (*data) {
+		if (strncmp (data,"base64",6) == 0) {
+			/* base64-encoding */
+			data_is_base64 = 1;
+			data_is_image = 1; // Illustrator produces embedded images without MIME type, so we assume it's image no matter what
+			data += 6;
+		}
+		else if (strncmp (data,"image/png",9) == 0) {
+			/* PNG image */
+			data_is_image = 1;
+			data += 9;
+		}
+		else if (strncmp (data,"image/jpg",9) == 0) {
+			/* JPEG image */
+			data_is_image = 1;
+			data += 9;
+		}
+		else if (strncmp (data,"image/jpeg",10) == 0) {
+			/* JPEG image */
+			data_is_image = 1;
+			data += 10;
+		}
+		else { /* unrecognized option; skip it */
+			while (*data) {
+				if (((*data) == ';') || ((*data) == ',')) break;
+				data++;
+			}
+		}
+		if ((*data) == ';') {
+			data++;
+			continue;
+		}
+		if ((*data) == ',') {
+			data++;
+			break;
+		}
+	}
+
+	if ((*data) && data_is_image && data_is_base64) {
+		pixbuf = sp_image_repr_read_b64 (data);
+	}
+
+	return pixbuf;
+}
+
+static GdkPixbuf *
+sp_image_repr_read_b64 (const gchar * uri_data)
+{	GdkPixbuf * pixbuf = NULL;
+	GdkPixbufLoader * loader = NULL;
+
+	gint j;
+	gint k;
+	gint l;
+	gint b;
+	gint len;
+	gint eos = 0;
+	gint failed = 0;
+
+	guint32 bits;
+
+	static const gchar B64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	const gchar* btr = uri_data;
+
+	gchar ud[4];
+
+	guchar bd[57];
+
+	loader = gdk_pixbuf_loader_new ();
+
+	if (loader == NULL) return NULL;
+
+	while (eos == 0) {
+		l = 0;
+		for (j = 0; j < 19; j++) {
+			len = 0;
+			for (k = 0; k < 4; k++) {
+				while (isspace ((int) (*btr))) {
+					if ((*btr) == '\0') break;
+					btr++;
+				}
+				if (eos) {
+					ud[k] = 0;
+					continue;
+				}
+				if (((*btr) == '\0') || ((*btr) == '=')) {
+					eos = 1;
+					ud[k] = 0;
+					continue;
+				}
+				ud[k] = 64;
+				for (b = 0; b < 64; b++) { /* There must a faster way to do this... ?? */
+					if (B64[b] == (*btr)) {
+						ud[k] = (gchar) b;
+						break;
+					}
+				}
+				if (ud[k] == 64) { /* data corruption ?? */
+					eos = 1;
+					ud[k] = 0;
+					continue;
+				}
+				btr++;
+				len++;
+			}
+			bits = (guint32) ud[0];
+			bits = (bits << 6) | (guint32) ud[1];
+			bits = (bits << 6) | (guint32) ud[2];
+			bits = (bits << 6) | (guint32) ud[3];
+			bd[l++] = (guchar) ((bits & 0xff0000) >> 16);
+			if (len > 2) {
+				bd[l++] = (guchar) ((bits & 0xff00) >>  8);
+			}
+			if (len > 3) {
+				bd[l++] = (guchar)  (bits & 0xff);
+			}
+		}
+
+		if (!gdk_pixbuf_loader_write (loader, (const guchar *) bd, (size_t) l, NULL)) {
+			failed = 1;
+			break;
+		}
+	}
+
+	gdk_pixbuf_loader_close (loader, NULL);
+
+	if (!failed) pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
+
+	return pixbuf;
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :