X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fsp-gradient.cpp;h=1b8f9a11137a0e1e311200c2c00ca7ad97a81145;hb=c7cf14ac71346f76ae219ce67fb88c1bd34832e2;hp=db2360225c6c4b033e0115b7bd46602bfdaeb09e;hpb=6b15695578f07a3f72c4c9475c1a261a3021472a;p=inkscape.git

diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index db2360225..1b8f9a111 100644
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
@@ -1,5 +1,3 @@
-#define __SP_GRADIENT_C__
-
 /** \file
  * SPGradient, SPStop, SPLinearGradient, SPRadialGradient.
  */
@@ -7,10 +5,14 @@
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
+ *   Jasper van de Gronde <th.v.d.gronde@hccnet.nl>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
  *
  * Copyright (C) 1999-2002 Lauris Kaplinski
  * Copyright (C) 2000-2001 Ximian, Inc.
  * Copyright (C) 2004 David Turner
+ * Copyright (C) 2009 Jasper van de Gronde
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  *
@@ -18,20 +20,25 @@
 
 #define noSP_GRADIENT_VERBOSE
 
+#include <cstring>
+#include <string>
 
-#include <libnr/nr-matrix-div.h>
 #include <libnr/nr-matrix-fns.h>
 #include <libnr/nr-matrix-ops.h>
 #include <libnr/nr-matrix-scale-ops.h>
-#include <libnr/nr-matrix-translate-ops.h>
-#include "libnr/nr-scale-translate-ops.h"
+#include <2geom/transforms.h>
 
+#include <sigc++/functors/ptr_fun.h>
+#include <sigc++/adaptors/bind.h>
 
-#include "display/nr-gradient-gpl.h"
+#include "libnr/nr-gradient.h"
+#include "libnr/nr-pixops.h"
 #include "svg/svg.h"
+#include "svg/svg-color.h"
 #include "svg/css-ostringstream.h"
 #include "attributes.h"
 #include "document-private.h"
+#include "sp-gradient.h"
 #include "gradient-chemistry.h"
 #include "sp-gradient-reference.h"
 #include "sp-linear-gradient.h"
@@ -40,11 +47,12 @@
 #include "streq.h"
 #include "uri.h"
 #include "xml/repr.h"
+#include "style.h"
 
 #define SP_MACROS_SILENT
 #include "macros.h"
 
-/// Has to be power of 2 
+/// Has to be power of 2
 #define NCOLORS NR_GRADIENT_VECTOR_LENGTH
 
 static void sp_stop_class_init(SPStopClass *klass);
@@ -52,10 +60,33 @@ static void sp_stop_init(SPStop *stop);
 
 static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
 static void sp_stop_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_stop_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static Inkscape::XML::Node *sp_stop_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
 
 static SPObjectClass *stop_parent_class;
 
+class SPGradientImpl
+{
+    friend class SPGradient;
+
+    static void classInit(SPGradientClass *klass);
+
+    static void init(SPGradient *gr);
+    static void build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+    static void release(SPObject *object);
+    static void modified(SPObject *object, guint flags);
+    static Inkscape::XML::Node *write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+
+    static void gradientRefModified(SPObject *href, guint flags, SPGradient *gradient);
+    static void gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr);
+
+    static void childAdded(SPObject *object,
+                           Inkscape::XML::Node *child,
+                           Inkscape::XML::Node *ref);
+    static void removeChild(SPObject *object, Inkscape::XML::Node *child);
+
+    static void setGradientAttr(SPObject *object, unsigned key, gchar const *value);
+};
+
 /**
  * Registers SPStop class and returns its type.
  */
@@ -101,7 +132,7 @@ sp_stop_init(SPStop *stop)
 {
     stop->offset = 0.0;
     stop->currentColor = false;
-    sp_color_set_rgb_rgba32(&stop->specified_color, 0x000000ff);
+    stop->specified_color.set( 0x000000ff );
     stop->opacity = 1.0;
 }
 
@@ -113,10 +144,10 @@ static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML:
     if (((SPObjectClass *) stop_parent_class)->build)
         (* ((SPObjectClass *) stop_parent_class)->build)(object, document, repr);
 
-    sp_object_read_attr(object, "offset");
-    sp_object_read_attr(object, "stop-color");
-    sp_object_read_attr(object, "stop-opacity");
-    sp_object_read_attr(object, "style");
+    object->readAttr( "offset" );
+    object->readAttr( "stop-color" );
+    object->readAttr( "stop-opacity" );
+    object->readAttr( "style" );
 }
 
 /**
@@ -135,21 +166,20 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
          * We need presentation attributes etc.
          * \par
          * remove the hackish "style reading" from here: see comments in
-         * sp_object_get_style_property about the bugs in our current 
-         * approach.  However, note that SPStyle doesn't currently have 
+         * sp_object_get_style_property about the bugs in our current
+         * approach.  However, note that SPStyle doesn't currently have
          * stop-color and stop-opacity properties.
          */
             {
-                gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
+                gchar const *p = object->getStyleProperty( "stop-color", "black");
                 if (streq(p, "currentColor")) {
                     stop->currentColor = true;
                 } else {
-                    guint32 const color = sp_svg_read_color(p, 0);                    
-                    sp_color_set_rgb_rgba32(&stop->specified_color, color);
+                    stop->specified_color = SPStop::readStopColor( p );
                 }
             }
             {
-                gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
+                gchar const *p = object->getStyleProperty( "stop-opacity", "1");
                 gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
                 stop->opacity = opacity;
             }
@@ -158,13 +188,12 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
         }
         case SP_PROP_STOP_COLOR: {
             {
-                gchar const *p = sp_object_get_style_property(object, "stop-color", "black");
+                gchar const *p = object->getStyleProperty( "stop-color", "black");
                 if (streq(p, "currentColor")) {
                     stop->currentColor = true;
                 } else {
                     stop->currentColor = false;
-                    guint32 const color = sp_svg_read_color(p, 0);
-                    sp_color_set_rgb_rgba32(&stop->specified_color, color);
+                    stop->specified_color = SPStop::readStopColor( p );
                 }
             }
             object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
@@ -172,7 +201,7 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
         }
         case SP_PROP_STOP_OPACITY: {
             {
-                gchar const *p = sp_object_get_style_property(object, "stop-opacity", "1");
+                gchar const *p = object->getStyleProperty( "stop-opacity", "1");
                 gdouble opacity = sp_svg_read_percentage(p, stop->opacity);
                 stop->opacity = opacity;
             }
@@ -181,7 +210,7 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
         }
         case SP_ATTR_OFFSET: {
             stop->offset = sp_svg_read_percentage(value, 0.0);
-            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            object->requestModified(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
             break;
         }
         default: {
@@ -196,25 +225,33 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
  * Virtual write: write object attributes to repr.
  */
 static Inkscape::XML::Node *
-sp_stop_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
     SPStop *stop = SP_STOP(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
-        repr = sp_repr_new("svg:stop");
+        repr = xml_doc->createElement("svg:stop");
     }
 
+    Glib::ustring colorStr = stop->specified_color.toString();
+    gfloat opacity = stop->opacity;
+
+    if (((SPObjectClass *) stop_parent_class)->write) {
+        (* ((SPObjectClass *) stop_parent_class)->write)(object, xml_doc, repr, flags);
+    }
+
+    // Since we do a hackish style setting here (because SPStyle does not support stop-color and
+    // stop-opacity), we must do it AFTER calling the parent write method; otherwise
+    // sp_object_write would clear our style= attribute (bug 1695287)
 
     Inkscape::CSSOStringStream os;
     os << "stop-color:";
     if (stop->currentColor) {
         os << "currentColor";
     } else {
-        gchar c[64];
-        sp_svg_write_color(c, 64, sp_color_get_rgba32_ualpha(&stop->specified_color, 255));
-        os << c;
+        os << colorStr;
     }
-    os << ";stop-opacity:" << stop->opacity;
+    os << ";stop-opacity:" << opacity;
     repr->setAttribute("style", os.str().c_str());
     repr->setAttribute("stop-color", NULL);
     repr->setAttribute("stop-opacity", NULL);
@@ -222,12 +259,46 @@ sp_stop_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
     /* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no sense
      * for offset proportions. */
 
-    if (((SPObjectClass *) stop_parent_class)->write)
-        (* ((SPObjectClass *) stop_parent_class)->write)(object, repr, flags);
-
     return repr;
 }
 
+
+bool SPGradient::hasStops() const
+{
+    return has_stops;
+}
+
+bool SPGradient::isUnitsSet() const
+{
+    return units_set;
+}
+
+SPGradientUnits SPGradient::getUnits() const
+{
+    return units;
+}
+
+bool SPGradient::isSpreadSet() const
+{
+    return spread_set;
+}
+
+SPGradientSpread SPGradient::getSpread() const
+{
+    return spread;
+}
+
+void SPGradient::setSwatch( bool swatch )
+{
+    if ( swatch != isSwatch() ) {
+        this->swatch = swatch; // to make isSolid() work, this happens first
+        gchar const* paintVal = swatch ? (isSolid() ? "solid" : "gradient") : 0;
+        setAttribute( "osb:paint", paintVal, 0 );
+
+        requestModified( SP_OBJECT_MODIFIED_FLAG );
+    }
+}
+
 /**
  * Return stop's color as 32bit value.
  */
@@ -239,7 +310,7 @@ sp_stop_get_rgba32(SPStop const *const stop)
      * value depends on user agent, and don't give any further restrictions that I can
      * see.) */
     if (stop->currentColor) {
-        char const *str = sp_object_get_style_property(stop, "color", NULL);
+        char const *str = stop->getStyleProperty( "color", NULL);
         if (str) {
             rgb0 = sp_svg_read_color(str, rgb0);
         }
@@ -248,31 +319,7 @@ sp_stop_get_rgba32(SPStop const *const stop)
                              rgb0 | 0xff);
         return rgb0 | alpha;
     } else {
-        return sp_color_get_rgba32_falpha(&stop->specified_color, stop->opacity);
-    }
-}
-
-/**
- * Return stop's color as SPColor.
- */
-static SPColor
-sp_stop_get_color(SPStop const *const stop)
-{
-    if (stop->currentColor) {
-        char const *str = sp_object_get_style_property(stop, "color", NULL);
-        guint32 const dfl = 0;
-        /* Default value: arbitrarily black.  (SVG1.1 and CSS2 both say that the initial
-         * value depends on user agent, and don't give any further restrictions that I can
-         * see.) */
-        guint32 color = dfl;
-        if (str) {
-            color = sp_svg_read_color(str, dfl);
-        }
-        SPColor ret;
-        sp_color_set_rgb_rgba32(&ret, color);
-        return ret;
-    } else {
-        return stop->specified_color;
+        return stop->specified_color.toRGBA32( stop->opacity );
     }
 }
 
@@ -280,45 +327,23 @@ sp_stop_get_color(SPStop const *const stop)
  * Gradient
  */
 
-static void sp_gradient_class_init(SPGradientClass *klass);
-static void sp_gradient_init(SPGradient *gr);
-
-static void sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
-static void sp_gradient_release(SPObject *object);
-static void sp_gradient_set(SPObject *object, unsigned key, gchar const *value);
-static void sp_gradient_child_added(SPObject *object,
-                                    Inkscape::XML::Node *child,
-                                    Inkscape::XML::Node *ref);
-static void sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child);
-static void sp_gradient_modified(SPObject *object, guint flags);
-static Inkscape::XML::Node *sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr,
-                                              guint flags);
-
-static void gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient);
-
-static bool sp_gradient_invalidate_vector(SPGradient *gr);
-static void sp_gradient_rebuild_vector(SPGradient *gr);
-
-static void gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gradient);
-
 static SPPaintServerClass *gradient_parent_class;
 
 /**
  * Registers SPGradient class and returns its type.
  */
-GType
-sp_gradient_get_type()
+GType SPGradient::getType()
 {
     static GType gradient_type = 0;
     if (!gradient_type) {
         GTypeInfo gradient_info = {
             sizeof(SPGradientClass),
             NULL, NULL,
-            (GClassInitFunc) sp_gradient_class_init,
+            (GClassInitFunc) SPGradientImpl::classInit,
             NULL, NULL,
             sizeof(SPGradient),
             16,
-            (GInstanceInitFunc) sp_gradient_init,
+            (GInstanceInitFunc) SPGradientImpl::init,
             NULL,   /* value_table */
         };
         gradient_type = g_type_register_static(SP_TYPE_PAINT_SERVER, "SPGradient",
@@ -330,30 +355,28 @@ sp_gradient_get_type()
 /**
  * SPGradient vtable initialization.
  */
-static void
-sp_gradient_class_init(SPGradientClass *klass)
+void SPGradientImpl::classInit(SPGradientClass *klass)
 {
     SPObjectClass *sp_object_class = (SPObjectClass *) klass;
 
     gradient_parent_class = (SPPaintServerClass *)g_type_class_ref(SP_TYPE_PAINT_SERVER);
 
-    sp_object_class->build = sp_gradient_build;
-    sp_object_class->release = sp_gradient_release;
-    sp_object_class->set = sp_gradient_set;
-    sp_object_class->child_added = sp_gradient_child_added;
-    sp_object_class->remove_child = sp_gradient_remove_child;
-    sp_object_class->modified = sp_gradient_modified;
-    sp_object_class->write = sp_gradient_write;
+    sp_object_class->build = SPGradientImpl::build;
+    sp_object_class->release = SPGradientImpl::release;
+    sp_object_class->set = SPGradientImpl::setGradientAttr;
+    sp_object_class->child_added = SPGradientImpl::childAdded;
+    sp_object_class->remove_child = SPGradientImpl::removeChild;
+    sp_object_class->modified = SPGradientImpl::modified;
+    sp_object_class->write = SPGradientImpl::write;
 }
 
 /**
  * Callback for SPGradient object initialization.
  */
-static void
-sp_gradient_init(SPGradient *gr)
+void SPGradientImpl::init(SPGradient *gr)
 {
     gr->ref = new SPGradientReference(SP_OBJECT(gr));
-    gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(gradient_ref_changed), gr));
+    gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(SPGradientImpl::gradientRefChanged), gr));
 
     /** \todo
      * Fixme: reprs being rearranged (e.g. via the XML editor)
@@ -364,7 +387,7 @@ sp_gradient_init(SPGradient *gr)
     gr->units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
     gr->units_set = FALSE;
 
-    gr->gradientTransform = NR::identity();
+    gr->gradientTransform = Geom::identity();
     gr->gradientTransform_set = FALSE;
 
     gr->spread = SP_GRADIENT_SPREAD_PAD;
@@ -376,57 +399,61 @@ sp_gradient_init(SPGradient *gr)
     gr->vector.stops.clear();
 
     gr->color = NULL;
+
+    new (&gr->modified_connection) sigc::connection();
 }
 
 /**
  * Virtual build: set gradient attributes from its associated repr.
  */
-static void
-sp_gradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+void SPGradientImpl::build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
     SPGradient *gradient = SP_GRADIENT(object);
 
-    if (((SPObjectClass *) gradient_parent_class)->build)
+    // Work-around in case a swatch had been marked for immediate collection:
+    if ( repr->attribute("osb:paint") && repr->attribute("inkscape:collect") ) {
+        repr->setAttribute("inkscape:collect", 0);
+    }
+
+    if (((SPObjectClass *) gradient_parent_class)->build) {
         (* ((SPObjectClass *) gradient_parent_class)->build)(object, document, repr);
+    }
 
-    SPObject *ochild;
-    for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
+    for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
         if (SP_IS_STOP(ochild)) {
             gradient->has_stops = TRUE;
             break;
         }
     }
 
-    sp_object_read_attr(object, "gradientUnits");
-    sp_object_read_attr(object, "gradientTransform");
-    sp_object_read_attr(object, "spreadMethod");
-    sp_object_read_attr(object, "xlink:href");
+    object->readAttr( "gradientUnits" );
+    object->readAttr( "gradientTransform" );
+    object->readAttr( "spreadMethod" );
+    object->readAttr( "xlink:href" );
+    object->readAttr( "osb:paint" );
 
-    /* Register ourselves */
-    sp_document_add_resource(document, "gradient", object);
+    // Register ourselves
+    document->addResource("gradient", object);
 }
 
 /**
  * Virtual release of SPGradient members before destruction.
  */
-static void
-sp_gradient_release(SPObject *object)
+void SPGradientImpl::release(SPObject *object)
 {
     SPGradient *gradient = (SPGradient *) object;
 
 #ifdef SP_GRADIENT_VERBOSE
-    g_print("Releasing gradient %s\n", SP_OBJECT_ID(object));
+    g_print("Releasing gradient %s\n", object->getId());
 #endif
 
     if (SP_OBJECT_DOCUMENT(object)) {
         /* Unregister ourselves */
-        sp_document_remove_resource(SP_OBJECT_DOCUMENT(object), "gradient", SP_OBJECT(object));
+        SP_OBJECT_DOCUMENT(object)->removeResource("gradient", SP_OBJECT(object));
     }
 
     if (gradient->ref) {
-        if (gradient->ref->getObject()) {
-            sp_signal_disconnect_by_data(gradient->ref->getObject(), gradient);
-        }
+        gradient->modified_connection.disconnect();
         gradient->ref->detach();
         delete gradient->ref;
         gradient->ref = NULL;
@@ -437,6 +464,8 @@ sp_gradient_release(SPObject *object)
         gradient->color = NULL;
     }
 
+    gradient->modified_connection.~connection();
+
     if (((SPObjectClass *) gradient_parent_class)->release)
         ((SPObjectClass *) gradient_parent_class)->release(object);
 }
@@ -444,8 +473,7 @@ sp_gradient_release(SPObject *object)
 /**
  * Set gradient attribute to value.
  */
-static void
-sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
+void SPGradientImpl::setGradientAttr(SPObject *object, unsigned key, gchar const *value)
 {
     SPGradient *gr = SP_GRADIENT(object);
 
@@ -465,12 +493,12 @@ sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         case SP_ATTR_GRADIENTTRANSFORM: {
-            NR::Matrix t;
+            Geom::Matrix t;
             if (value && sp_svg_transform_read(value, &t)) {
                 gr->gradientTransform = t;
                 gr->gradientTransform_set = TRUE;
             } else {
-                gr->gradientTransform = NR::identity();
+                gr->gradientTransform = Geom::identity();
                 gr->gradientTransform_set = FALSE;
             }
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
@@ -503,9 +531,31 @@ sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
                 gr->ref->detach();
             }
             break;
+        case SP_ATTR_OSB_SWATCH:
+        {
+            bool newVal = (value != 0);
+            bool modified = false;
+            if (newVal != gr->swatch) {
+                gr->swatch = newVal;
+                modified = true;
+            }
+            if (newVal) {
+                // Might need to flip solid/gradient
+                Glib::ustring paintVal = ( gr->hasStops() && (gr->getStopCount() == 0) ) ? "solid" : "gradient";
+                if ( paintVal != value ) {
+                    gr->setAttribute( "osb:paint", paintVal.c_str(), 0 );
+                    modified = true;
+                }
+            }
+            if (modified) {
+                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            }
+        }
+            break;
         default:
-            if (((SPObjectClass *) gradient_parent_class)->set)
+            if (((SPObjectClass *) gradient_parent_class)->set) {
                 ((SPObjectClass *) gradient_parent_class)->set(object, key, value);
+            }
             break;
     }
 }
@@ -513,37 +563,54 @@ sp_gradient_set(SPObject *object, unsigned key, gchar const *value)
 /**
  * Gets called when the gradient is (re)attached to another gradient.
  */
-static void
-gradient_ref_changed(SPObject *old_ref, SPObject *ref, SPGradient *gr)
+void SPGradientImpl::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr)
 {
     if (old_ref) {
-        sp_signal_disconnect_by_data(old_ref, gr);
+        gr->modified_connection.disconnect();
     }
     if ( SP_IS_GRADIENT(ref)
          && ref != gr )
     {
-        g_signal_connect(G_OBJECT(ref), "modified", G_CALLBACK(gradient_ref_modified), gr);
+        gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&SPGradientImpl::gradientRefModified), gr));
+    }
+
+    // Per SVG, all unset attributes must be inherited from linked gradient.
+    // So, as we're now (re)linked, we assign linkee's values to this gradient if they are not yet set -
+    // but without setting the _set flags.
+    // FIXME: do the same for gradientTransform too
+    if (!gr->units_set) {
+        gr->units = gr->fetchUnits();
+    }
+    if (!gr->spread_set) {
+        gr->spread = gr->fetchSpread();
     }
+
     /// \todo Fixme: what should the flags (second) argument be? */
-    gradient_ref_modified(ref, 0, gr);
+    gradientRefModified(ref, 0, gr);
 }
 
 /**
  * Callback for child_added event.
  */
-static void
-sp_gradient_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
+void SPGradientImpl::childAdded(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 {
     SPGradient *gr = SP_GRADIENT(object);
 
-    sp_gradient_invalidate_vector(gr);
+    gr->invalidateVector();
 
-    if (((SPObjectClass *) gradient_parent_class)->child_added)
+    if (((SPObjectClass *) gradient_parent_class)->child_added) {
         (* ((SPObjectClass *) gradient_parent_class)->child_added)(object, child, ref);
+    }
 
-    SPObject *ochild = sp_object_get_child_by_repr(object, child);
+    SPObject *ochild = object->get_child_by_repr(child);
     if ( ochild && SP_IS_STOP(ochild) ) {
         gr->has_stops = TRUE;
+        if ( gr->getStopCount() > 0 ) {
+            gchar const * attr = gr->getAttribute("osb:paint");
+            if ( attr && strcmp(attr, "gradient") ) {
+                gr->setAttribute( "osb:paint", "gradient", 0 );
+            }
+        }
     }
 
     /// \todo Fixme: should we schedule "modified" here?
@@ -553,25 +620,31 @@ sp_gradient_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::
 /**
  * Callback for remove_child event.
  */
-static void
-sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child)
+void SPGradientImpl::removeChild(SPObject *object, Inkscape::XML::Node *child)
 {
     SPGradient *gr = SP_GRADIENT(object);
 
-    sp_gradient_invalidate_vector(gr);
+    gr->invalidateVector();
 
-    if (((SPObjectClass *) gradient_parent_class)->remove_child)
+    if (((SPObjectClass *) gradient_parent_class)->remove_child) {
         (* ((SPObjectClass *) gradient_parent_class)->remove_child)(object, child);
+    }
 
     gr->has_stops = FALSE;
-    SPObject *ochild;
-    for ( ochild = sp_object_first_child(object) ; ochild ; ochild = SP_OBJECT_NEXT(ochild) ) {
+    for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
         if (SP_IS_STOP(ochild)) {
             gr->has_stops = TRUE;
             break;
         }
     }
 
+    if ( gr->getStopCount() == 0 ) {
+        gchar const * attr = gr->getAttribute("osb:paint");
+        if ( attr && strcmp(attr, "solid") ) {
+            gr->setAttribute( "osb:paint", "solid", 0 );
+        }
+    }
+
     /* Fixme: should we schedule "modified" here? */
     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
@@ -579,13 +652,16 @@ sp_gradient_remove_child(SPObject *object, Inkscape::XML::Node *child)
 /**
  * Callback for modified event.
  */
-static void
-sp_gradient_modified(SPObject *object, guint flags)
+void SPGradientImpl::modified(SPObject *object, guint flags)
 {
     SPGradient *gr = SP_GRADIENT(object);
 
     if (flags & SP_OBJECT_CHILD_MODIFIED_FLAG) {
-        sp_gradient_invalidate_vector(gr);
+        gr->invalidateVector();
+    }
+
+    if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
+        gr->ensureColors();
     }
 
     if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
@@ -593,7 +669,7 @@ sp_gradient_modified(SPObject *object, guint flags)
 
     // FIXME: climb up the ladder of hrefs
     GSList *l = NULL;
-    for (SPObject *child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
+    for (SPObject *child = object->firstChild() ; child; child = child->getNext() ) {
         g_object_ref(G_OBJECT(child));
         l = g_slist_prepend(l, child);
     }
@@ -608,23 +684,46 @@ sp_gradient_modified(SPObject *object, guint flags)
     }
 }
 
+SPStop* SPGradient::getFirstStop()
+{
+    SPStop* first = 0;
+    for (SPObject *ochild = firstChild(); ochild && !first; ochild = ochild->getNext()) {
+        if (SP_IS_STOP(ochild)) {
+            first = SP_STOP(ochild);
+        }
+    }
+    return first;
+}
+
+int SPGradient::getStopCount() const
+{
+    int count = 0;
+
+    for (SPStop *stop = const_cast<SPGradient*>(this)->getFirstStop(); stop && stop->getNextStop(); stop = stop->getNextStop()) {
+        count++;
+    }
+
+    return count;
+}
+
 /**
  * Write gradient attributes to repr.
  */
-static Inkscape::XML::Node *
-sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+Inkscape::XML::Node *SPGradientImpl::write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
     SPGradient *gr = SP_GRADIENT(object);
 
-    if (((SPObjectClass *) gradient_parent_class)->write)
-        (* ((SPObjectClass *) gradient_parent_class)->write)(object, repr, flags);
+    if (((SPObjectClass *) gradient_parent_class)->write) {
+        (* ((SPObjectClass *) gradient_parent_class)->write)(object, xml_doc, repr, flags);
+    }
 
     if (flags & SP_OBJECT_WRITE_BUILD) {
         GSList *l = NULL;
-        for (SPObject *child = sp_object_first_child(object); child; child = SP_OBJECT_NEXT(child)) {
-            Inkscape::XML::Node *crepr;
-            crepr = child->updateRepr(NULL, flags);
-            if (crepr) l = g_slist_prepend(l, crepr);
+        for (SPObject *child = object->firstChild(); child; child = child->getNext()) {
+            Inkscape::XML::Node *crepr = child->updateRepr(xml_doc, NULL, flags);
+            if (crepr) {
+                l = g_slist_prepend(l, crepr);
+            }
         }
         while (l) {
             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
@@ -651,17 +750,14 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
     }
 
     if ((flags & SP_OBJECT_WRITE_ALL) || gr->gradientTransform_set) {
-        gchar c[256];
-        if (sp_svg_transform_write(c, 256, gr->gradientTransform)) {
-            repr->setAttribute("gradientTransform", c);
-        } else {
-            repr->setAttribute("gradientTransform", NULL);
-        }
+        gchar *c=sp_svg_transform_write(gr->gradientTransform);
+        repr->setAttribute("gradientTransform", c);
+        g_free(c);
     }
 
     if ((flags & SP_OBJECT_WRITE_ALL) || gr->spread_set) {
         /* FIXME: Ensure that gr->spread is the inherited value
-         * if !gr->spread_set.  Not currently happening: see sp_gradient_modified.
+         * if !gr->spread_set.  Not currently happening: see SPGradient::modified.
          */
         switch (gr->spread) {
             case SP_GRADIENT_SPREAD_REFLECT:
@@ -676,6 +772,16 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
         }
     }
 
+    if ( (flags & SP_OBJECT_WRITE_EXT) && gr->isSwatch() ) {
+        if ( gr->isSolid() ) {
+            repr->setAttribute( "osb:paint", "solid" );
+        } else {
+            repr->setAttribute( "osb:paint", "gradient" );
+        }
+    } else {
+        repr->setAttribute( "osb:paint", 0 );
+    }
+
     return repr;
 }
 
@@ -684,40 +790,34 @@ sp_gradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
  *
  * \pre SP_IS_GRADIENT(gradient).
  */
-void
-sp_gradient_ensure_vector(SPGradient *gradient)
+void SPGradient::ensureVector()
 {
-    g_return_if_fail(gradient != NULL);
-    g_return_if_fail(SP_IS_GRADIENT(gradient));
-
-    if (!gradient->vector.built) {
-        sp_gradient_rebuild_vector(gradient);
+    if ( !vector.built ) {
+        rebuildVector();
     }
 }
 
 /**
  * Set units property of gradient and emit modified.
  */
-void
-sp_gradient_set_units(SPGradient *gr, SPGradientUnits units)
+void SPGradient::setUnits(SPGradientUnits units)
 {
-    if (units != gr->units) {
-        gr->units = units;
-        gr->units_set = TRUE;
-        SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    if (units != this->units) {
+        this->units = units;
+        units_set = TRUE;
+        requestModified(SP_OBJECT_MODIFIED_FLAG);
     }
 }
 
 /**
  * Set spread property of gradient and emit modified.
  */
-void
-sp_gradient_set_spread(SPGradient *gr, SPGradientSpread spread)
+void SPGradient::setSpread(SPGradientSpread spread)
 {
-    if (spread != gr->spread) {
-        gr->spread = spread;
-        gr->spread_set = TRUE;
-        SP_OBJECT(gr)->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    if (spread != this->spread) {
+        this->spread = spread;
+        spread_set = TRUE;
+        requestModified(SP_OBJECT_MODIFIED_FLAG);
     }
 }
 
@@ -766,39 +866,37 @@ chase_hrefs(SPGradient *const src, bool (*match)(SPGradient const *))
 /**
  * True if gradient has stops.
  */
-static bool
-has_stops(SPGradient const *gr)
+static bool has_stopsFN(SPGradient const *gr)
 {
-    return SP_GRADIENT_HAS_STOPS(gr);
+    return gr->hasStops();
 }
 
 /**
  * True if gradient has spread set.
  */
-static bool
-has_spread_set(SPGradient const *gr)
+static bool has_spread_set(SPGradient const *gr)
 {
-    return gr->spread_set;
+    return gr->isSpreadSet();
 }
 
-
 /**
- * Returns private vector of given gradient (the gradient at the end of the href chain which has
- * stops), optionally normalizing it.
- *
- * \pre SP_IS_GRADIENT(gradient).
- * \pre There exists a gradient in the chain that has stops.
+ * True if gradient has units set.
  */
-SPGradient *
-sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
+static bool
+has_units_set(SPGradient const *gr)
 {
-    g_return_val_if_fail(gradient != NULL, NULL);
-    g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
+    return gr->isUnitsSet();
+}
+
 
-    SPGradient *const src = chase_hrefs(gradient, has_stops);
-    return ( force_vector
-             ? sp_gradient_ensure_vector_normalized(src)
-             : src );
+SPGradient *SPGradient::getVector(bool force_vector)
+{
+    SPGradient * src = chase_hrefs(this, has_stopsFN);
+
+    if (force_vector) {
+        src = sp_gradient_ensure_vector_normalized(src);
+    }
+    return src;
 }
 
 /**
@@ -806,17 +904,28 @@ sp_gradient_get_vector(SPGradient *gradient, bool force_vector)
  *
  * \pre SP_IS_GRADIENT(gradient).
  */
-SPGradientSpread
-sp_gradient_get_spread(SPGradient *gradient)
+SPGradientSpread SPGradient::fetchSpread()
 {
-    g_return_val_if_fail(SP_IS_GRADIENT(gradient), SP_GRADIENT_SPREAD_PAD);
-
-    SPGradient const *src = chase_hrefs(gradient, has_spread_set);
+    SPGradient const *src = chase_hrefs(this, has_spread_set);
     return ( src
              ? src->spread
              : SP_GRADIENT_SPREAD_PAD ); // pad is the default
 }
 
+/**
+ * Returns the effective units of given gradient (climbing up the refs chain if needed).
+ *
+ * \pre SP_IS_GRADIENT(gradient).
+ */
+SPGradientUnits SPGradient::fetchUnits()
+{
+    SPGradient const *src = chase_hrefs(this, has_units_set);
+    return ( src
+             ? src->units
+             : SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ); // bbox is the default
+}
+
+
 /**
  * Clears the gradient's svg:stop children from its repr.
  */
@@ -844,7 +953,7 @@ sp_gradient_repr_clear_vector(SPGradient *gr)
 }
 
 /**
- * Writes the gradient's internal vector (whether from its own stops, or 
+ * Writes the gradient's internal vector (whether from its own stops, or
  * inherited from refs) into the gradient repr as svg:stop elements.
  */
 void
@@ -853,6 +962,7 @@ sp_gradient_repr_write_vector(SPGradient *gr)
     g_return_if_fail(gr != NULL);
     g_return_if_fail(SP_IS_GRADIENT(gr));
 
+    Inkscape::XML::Document *xml_doc = SP_OBJECT_DOCUMENT(gr)->getReprDoc();
     Inkscape::XML::Node *repr = SP_OBJECT_REPR(gr);
 
     /* We have to be careful, as vector may be our own, so construct repr list at first */
@@ -860,13 +970,11 @@ sp_gradient_repr_write_vector(SPGradient *gr)
 
     for (guint i = 0; i < gr->vector.stops.size(); i++) {
         Inkscape::CSSOStringStream os;
-        Inkscape::XML::Node *child = sp_repr_new("svg:stop");
+        Inkscape::XML::Node *child = xml_doc->createElement("svg:stop");
         sp_repr_set_css_double(child, "offset", gr->vector.stops[i].offset);
         /* strictly speaking, offset an SVG <number> rather than a CSS one, but exponents make no
          * sense for offset proportions. */
-        gchar c[64];
-        sp_svg_write_color(c, 64, sp_color_get_rgba32_ualpha(&gr->vector.stops[i].color, 0x00));
-        os << "stop-color:" << c << ";stop-opacity:" << gr->vector.stops[i].opacity;
+        os << "stop-color:" << gr->vector.stops[i].color.toString() << ";stop-opacity:" << gr->vector.stops[i].opacity;
         child->setAttribute("style", os.str().c_str());
         /* Order will be reversed here */
         cl = g_slist_prepend(cl, child);
@@ -884,30 +992,28 @@ sp_gradient_repr_write_vector(SPGradient *gr)
 }
 
 
-static void
-gradient_ref_modified(SPObject *href, guint flags, SPGradient *gradient)
+void SPGradientImpl::gradientRefModified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
 {
-    if (sp_gradient_invalidate_vector(gradient)) {
+    if ( gradient->invalidateVector() ) {
         SP_OBJECT(gradient)->requestModified(SP_OBJECT_MODIFIED_FLAG);
-        /* Conditional to avoid causing infinite loop if there's a cycle in the href chain. */
+        // Conditional to avoid causing infinite loop if there's a cycle in the href chain.
     }
 }
 
-/** Return true iff change made. */
-static bool
-sp_gradient_invalidate_vector(SPGradient *gr)
+/** Return true if change made. */
+bool SPGradient::invalidateVector()
 {
     bool ret = false;
 
-    if (gr->color != NULL) {
-        g_free(gr->color);
-        gr->color = NULL;
+    if (color != NULL) {
+        g_free(color);
+        color = NULL;
         ret = true;
     }
 
-    if (gr->vector.built) {
-        gr->vector.built = false;
-        gr->vector.stops.clear();
+    if (vector.built) {
+        vector.built = false;
+        vector.stops.clear();
         ret = true;
     }
 
@@ -915,48 +1021,43 @@ sp_gradient_invalidate_vector(SPGradient *gr)
 }
 
 /** Creates normalized color vector */
-static void
-sp_gradient_rebuild_vector(SPGradient *gr)
+void SPGradient::rebuildVector()
 {
     gint len = 0;
-    for ( SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
-          child != NULL ;
-          child = SP_OBJECT_NEXT(child) ) {
+    for ( SPObject *child = firstChild() ; child ; child = child->getNext() ) {
         if (SP_IS_STOP(child)) {
             len ++;
         }
     }
 
-    gr->has_stops = (len != 0);
+    has_stops = (len != 0);
 
-    gr->vector.stops.clear();
+    vector.stops.clear();
 
-    SPGradient *ref = gr->ref->getObject();
-    if ( !gr->has_stops && ref ) {
+    SPGradient *reffed = ref->getObject();
+    if ( !hasStops() && reffed ) {
         /* Copy vector from referenced gradient */
-        gr->vector.built = true;   // Prevent infinite recursion.
-        sp_gradient_ensure_vector(ref);
-        if (!ref->vector.stops.empty()) {
-            gr->vector.built = ref->vector.built;
-            gr->vector.stops.assign(ref->vector.stops.begin(), ref->vector.stops.end());
+        vector.built = true;   // Prevent infinite recursion.
+        reffed->ensureVector();
+        if (!reffed->vector.stops.empty()) {
+            vector.built = reffed->vector.built;
+            vector.stops.assign(reffed->vector.stops.begin(), reffed->vector.stops.end());
             return;
         }
     }
 
-    for (SPObject *child = sp_object_first_child(SP_OBJECT(gr)) ;
-         child != NULL;
-         child = SP_OBJECT_NEXT(child) ) {
+    for ( SPObject *child = firstChild(); child; child = child->getNext() ) {
         if (SP_IS_STOP(child)) {
             SPStop *stop = SP_STOP(child);
 
             SPGradientStop gstop;
-            if (gr->vector.stops.size() > 0) {
+            if (vector.stops.size() > 0) {
                 // "Each gradient offset value is required to be equal to or greater than the
                 // previous gradient stop's offset value. If a given gradient stop's offset
                 // value is not equal to or greater than all previous offset values, then the
                 // offset value is adjusted to be equal to the largest of all previous offset
                 // values."
-                gstop.offset = MAX(stop->offset, gr->vector.stops.back().offset);
+                gstop.offset = MAX(stop->offset, vector.stops.back().offset);
             } else {
                 gstop.offset = stop->offset;
             }
@@ -966,114 +1067,204 @@ sp_gradient_rebuild_vector(SPGradient *gr)
             // down to 100%."
             gstop.offset = CLAMP(gstop.offset, 0, 1);
 
-            gstop.color = sp_stop_get_color(stop);
+            gstop.color = stop->getEffectiveColor();
             gstop.opacity = stop->opacity;
 
-            gr->vector.stops.push_back(gstop);
+            vector.stops.push_back(gstop);
         }
     }
 
     // Normalize per section 13.2.4 of SVG 1.1.
-    if (gr->vector.stops.size() == 0) {
+    if (vector.stops.size() == 0) {
         /* "If no stops are defined, then painting shall occur as if 'none' were specified as the
          * paint style."
          */
         {
             SPGradientStop gstop;
             gstop.offset = 0.0;
-            sp_color_set_rgb_rgba32(&gstop.color, 0x00000000);
+            gstop.color.set( 0x00000000 );
             gstop.opacity = 0.0;
-            gr->vector.stops.push_back(gstop);
+            vector.stops.push_back(gstop);
         }
         {
             SPGradientStop gstop;
             gstop.offset = 1.0;
-            sp_color_set_rgb_rgba32(&gstop.color, 0x00000000);
+            gstop.color.set( 0x00000000 );
             gstop.opacity = 0.0;
-            gr->vector.stops.push_back(gstop);
+            vector.stops.push_back(gstop);
         }
     } else {
         /* "If one stop is defined, then paint with the solid color fill using the color defined
          * for that gradient stop."
          */
-        if (gr->vector.stops.front().offset > 0.0) {
+        if (vector.stops.front().offset > 0.0) {
             // If the first one is not at 0, then insert a copy of the first at 0.
             SPGradientStop gstop;
             gstop.offset = 0.0;
-            sp_color_copy(&gstop.color, &gr->vector.stops.front().color);
-            gstop.opacity = gr->vector.stops.front().opacity;
-            gr->vector.stops.insert(gr->vector.stops.begin(), gstop);
+            gstop.color = vector.stops.front().color;
+            gstop.opacity = vector.stops.front().opacity;
+            vector.stops.insert(vector.stops.begin(), gstop);
         }
-        if (gr->vector.stops.back().offset < 1.0) {
+        if (vector.stops.back().offset < 1.0) {
             // If the last one is not at 1, then insert a copy of the last at 1.
             SPGradientStop gstop;
             gstop.offset = 1.0;
-            sp_color_copy(&gstop.color, &gr->vector.stops.back().color);
-            gstop.opacity = gr->vector.stops.back().opacity;
-            gr->vector.stops.push_back(gstop);
+            gstop.color = vector.stops.back().color;
+            gstop.opacity = vector.stops.back().opacity;
+            vector.stops.push_back(gstop);
         }
     }
 
-    gr->vector.built = true;
+    vector.built = true;
 }
 
 /**
  * The gradient's color array is newly created and set up from vector.
  */
-void
-sp_gradient_ensure_colors(SPGradient *gr)
+void SPGradient::ensureColors()
 {
-    if (!gr->vector.built) {
-        sp_gradient_rebuild_vector(gr);
+    if (!vector.built) {
+        rebuildVector();
     }
-    g_return_if_fail(!gr->vector.stops.empty());
+    g_return_if_fail(!vector.stops.empty());
 
     /// \todo Where is the memory freed?
-    if (!gr->color) {
-        gr->color = g_new(guchar, 4 * NCOLORS);
-    }
-
-    for (guint i = 0; i < gr->vector.stops.size() - 1; i++) {
-        guint32 color = sp_color_get_rgba32_falpha(&gr->vector.stops[i].color,
-                                                   gr->vector.stops[i].opacity);
-        gint r0 = (color >> 24) & 0xff;
-        gint g0 = (color >> 16) & 0xff;
-        gint b0 = (color >> 8) & 0xff;
-        gint a0 = color & 0xff;
-        color = sp_color_get_rgba32_falpha(&gr->vector.stops[i + 1].color,
-                                           gr->vector.stops[i + 1].opacity);
-        gint r1 = (color >> 24) & 0xff;
-        gint g1 = (color >> 16) & 0xff;
-        gint b1 = (color >> 8) & 0xff;
-        gint a1 = color & 0xff;
-        gint o0 = (gint) floor(gr->vector.stops[i].offset * (NCOLORS - 0.001));
-        gint o1 = (gint) floor(gr->vector.stops[i + 1].offset * (NCOLORS - 0.001));
-        if (o1 > o0) {
-            gint dr = ((r1 - r0) << 16) / (o1 - o0);
-            gint dg = ((g1 - g0) << 16) / (o1 - o0);
-            gint db = ((b1 - b0) << 16) / (o1 - o0);
-            gint da = ((a1 - a0) << 16) / (o1 - o0);
-            gint r = r0 << 16;
-            gint g = g0 << 16;
-            gint b = b0 << 16;
-            gint a = a0 << 16;
-            for (int j = o0; j < o1 + 1; j++) {
-                gr->color[4 * j] = r >> 16;
-                gr->color[4 * j + 1] = g >> 16;
-                gr->color[4 * j + 2] = b >> 16;
-                gr->color[4 * j + 3] = a >> 16;
-                r += dr;
-                g += dg;
-                b += db;
-                a += da;
+    if (!color) {
+        color = g_new(guchar, 4 * NCOLORS);
+    }
+
+    // This assumes that vector is a zero-order B-spline (box function) approximation of the "true" gradient.
+    // This means that the "true" gradient must be prefiltered using a zero order B-spline and then sampled.
+    // Furthermore, the first element corresponds to offset="0" and the last element to offset="1".
+
+    double remainder[4] = {0,0,0,0};
+    double remainder_for_end[4] = {0,0,0,0}; // Used at the end
+    switch(spread) {
+    case SP_GRADIENT_SPREAD_PAD:
+        remainder[0] = 0.5*vector.stops[0].color.v.c[0]; // Half of the first cell uses the color of the first stop
+        remainder[1] = 0.5*vector.stops[0].color.v.c[1];
+        remainder[2] = 0.5*vector.stops[0].color.v.c[2];
+        remainder[3] = 0.5*vector.stops[0].opacity;
+        remainder_for_end[0] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[0]; // Half of the first cell uses the color of the last stop
+        remainder_for_end[1] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[1];
+        remainder_for_end[2] = 0.5*vector.stops[vector.stops.size() - 1].color.v.c[2];
+        remainder_for_end[3] = 0.5*vector.stops[vector.stops.size() - 1].opacity;
+        break;
+    case SP_GRADIENT_SPREAD_REFLECT:
+    case SP_GRADIENT_SPREAD_REPEAT:
+        // These two are handled differently, see below.
+        break;
+    default:
+        g_error("Spread type not supported!");
+    };
+    for (unsigned int i = 0; i < vector.stops.size() - 1; i++) {
+        double r0 = vector.stops[i].color.v.c[0];
+        double g0 = vector.stops[i].color.v.c[1];
+        double b0 = vector.stops[i].color.v.c[2];
+        double a0 = vector.stops[i].opacity;
+        double r1 = vector.stops[i+1].color.v.c[0];
+        double g1 = vector.stops[i+1].color.v.c[1];
+        double b1 = vector.stops[i+1].color.v.c[2];
+        double a1 = vector.stops[i+1].opacity;
+        double o0 = vector.stops[i].offset * (NCOLORS-1);
+        double o1 = vector.stops[i + 1].offset * (NCOLORS-1);
+        unsigned int ob = (unsigned int) floor(o0+.5); // These are the first and last element that might be affected by this interval.
+        unsigned int oe = (unsigned int) floor(o1+.5); // These need to be computed the same to ensure that ob will be covered by the next interval if oe==ob
+
+        if (oe == ob) {
+            // Simple case, this interval starts and stops within one cell
+            // The contribution of this interval is:
+            //    (o1-o0)*(c(o0)+c(o1))/2
+            //  = (o1-o0)*(c0+c1)/2
+            double dt = 0.5*(o1-o0);
+            remainder[0] += dt*(r0 + r1);
+            remainder[1] += dt*(g0 + g1);
+            remainder[2] += dt*(b0 + b1);
+            remainder[3] += dt*(a0 + a1);
+        } else {
+            // First compute colors for the cells which are fully covered by the current interval.
+            // The prefiltered values are equal to the midpoint of each cell here.
+            //  f = (j-o0)/(o1-o0)
+            //    = j*(1/(o1-o0)) - o0/(o1-o0)
+            double f = (ob-o0) / (o1-o0);
+            double df = 1. / (o1-o0);
+            for (unsigned int j = ob+1; j < oe; j++) {
+                f += df;
+                color[4 * j + 0] = (unsigned char) floor(255*(r0 + f*(r1-r0)) + .5);
+                color[4 * j + 1] = (unsigned char) floor(255*(g0 + f*(g1-g0)) + .5);
+                color[4 * j + 2] = (unsigned char) floor(255*(b0 + f*(b1-b0)) + .5);
+                color[4 * j + 3] = (unsigned char) floor(255*(a0 + f*(a1-a0)) + .5);
+            }
+
+            // Now handle the beginning
+            // The contribution of the last point is already in remainder.
+            // The contribution of this point is:
+            //    (ob+.5-o0)*(c(o0)+c(ob+.5))/2
+            //  = (ob+.5-o0)*c((o0+ob+.5)/2)
+            //  = (ob+.5-o0)*(c0+((o0+ob+.5)/2-o0)*df*(c1-c0))
+            //  = (ob+.5-o0)*(c0+(ob+.5-o0)*df*(c1-c0)/2)
+            double dt = ob+.5-o0;
+            f = 0.5*dt*df;
+            if (ob==0 && spread==SP_GRADIENT_SPREAD_REFLECT) {
+                // The first half of the first cell is just a mirror image of the second half, so simply multiply it by 2.
+                color[4 * ob + 0] = (unsigned char) floor(2*255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
+                color[4 * ob + 1] = (unsigned char) floor(2*255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
+                color[4 * ob + 2] = (unsigned char) floor(2*255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
+                color[4 * ob + 3] = (unsigned char) floor(2*255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
+            } else if (ob==0 && spread==SP_GRADIENT_SPREAD_REPEAT) {
+                // The first cell is the same as the last cell, so save whatever is in the second half here and deal with the rest later.
+                remainder_for_end[0] = remainder[0] + dt*(r0 + f*(r1-r0));
+                remainder_for_end[1] = remainder[1] + dt*(g0 + f*(g1-g0));
+                remainder_for_end[2] = remainder[2] + dt*(b0 + f*(b1-b0));
+                remainder_for_end[3] = remainder[3] + dt*(a0 + f*(a1-a0));
+            } else {
+                // The first half of the cell was already in remainder.
+                color[4 * ob + 0] = (unsigned char) floor(255*(remainder[0] + dt*(r0 + f*(r1-r0))) + .5);
+                color[4 * ob + 1] = (unsigned char) floor(255*(remainder[1] + dt*(g0 + f*(g1-g0))) + .5);
+                color[4 * ob + 2] = (unsigned char) floor(255*(remainder[2] + dt*(b0 + f*(b1-b0))) + .5);
+                color[4 * ob + 3] = (unsigned char) floor(255*(remainder[3] + dt*(a0 + f*(a1-a0))) + .5);
             }
+
+            // Now handle the end, which should end up in remainder
+            // The contribution of this point is:
+            //    (o1-oe+.5)*(c(o1)+c(oe-.5))/2
+            //  = (o1-oe+.5)*c((o1+oe-.5)/2)
+            //  = (o1-oe+.5)*(c0+((o1+oe-.5)/2-o0)*df*(c1-c0))
+            dt = o1-oe+.5;
+            f = (0.5*(o1+oe-.5)-o0)*df;
+            remainder[0] = dt*(r0 + f*(r1-r0));
+            remainder[1] = dt*(g0 + f*(g1-g0));
+            remainder[2] = dt*(b0 + f*(b1-b0));
+            remainder[3] = dt*(a0 + f*(a1-a0));
         }
     }
+    switch(spread) {
+    case SP_GRADIENT_SPREAD_PAD:
+        color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
+        color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
+        color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
+        color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+        break;
+    case SP_GRADIENT_SPREAD_REFLECT:
+        // The second half is the same as the first half, so multiply by 2.
+        color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(2*255*remainder[0] + .5);
+        color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(2*255*remainder[1] + .5);
+        color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(2*255*remainder[2] + .5);
+        color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(2*255*remainder[3] + .5);
+        break;
+    case SP_GRADIENT_SPREAD_REPEAT:
+        // The second half is the same as the second half of the first cell (which was saved in remainder_for_end).
+        color[0] = color[4 * (NCOLORS-1) + 0] = (unsigned char) floor(255*(remainder[0]+remainder_for_end[0]) + .5);
+        color[1] = color[4 * (NCOLORS-1) + 1] = (unsigned char) floor(255*(remainder[1]+remainder_for_end[1]) + .5);
+        color[2] = color[4 * (NCOLORS-1) + 2] = (unsigned char) floor(255*(remainder[2]+remainder_for_end[2]) + .5);
+        color[3] = color[4 * (NCOLORS-1) + 3] = (unsigned char) floor(255*(remainder[3]+remainder_for_end[3]) + .5);
+        break;
+    }
 }
 
 /**
  * Renders gradient vector to buffer as line.
- * 
+ *
  * RGB buffer background should be set up beforehand.
  *
  * @param len,width,height,rowstride Buffer parameters (1 or 2 dimensional).
@@ -1093,7 +1284,7 @@ sp_gradient_render_vector_line_rgba(SPGradient *const gradient, guchar *buf,
     g_return_if_fail(span > 0);
 
     if (!gradient->color) {
-        sp_gradient_ensure_colors(gradient);
+        gradient->ensureColors();
     }
 
     gint idx = (pos * 1024 << 8) / span;
@@ -1149,10 +1340,10 @@ sp_gradient_render_vector_block_rgba(SPGradient *const gradient, guchar *buf,
 
 /**
  * Render rectangular RGB area from gradient vector.
- */ 
+ */
 void
 sp_gradient_render_vector_block_rgb(SPGradient *gradient, guchar *buf,
-                                    gint const width, gint const height, gint const rowstride,
+                                    gint const width, gint const height, gint const /*rowstride*/,
                                     gint const pos, gint const span, bool const horizontal)
 {
     g_return_if_fail(gradient != NULL);
@@ -1199,40 +1390,40 @@ sp_gradient_render_vector_block_rgb(SPGradient *gradient, guchar *buf,
     }
 }
 
-NR::Matrix
-sp_gradient_get_g2d_matrix(SPGradient const *gr, NR::Matrix const &ctm, NR::Rect const &bbox)
+Geom::Matrix
+sp_gradient_get_g2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
 {
-    if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
-        return ( NR::scale(bbox.dimensions())
-                 * NR::translate(bbox.min())
-                 * ctm );
+    if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
+        return ( Geom::Scale(bbox.dimensions())
+                 * Geom::Translate(bbox.min())
+                 * Geom::Matrix(ctm) );
     } else {
         return ctm;
     }
 }
 
-NR::Matrix
-sp_gradient_get_gs2d_matrix(SPGradient const *gr, NR::Matrix const &ctm, NR::Rect const &bbox)
+Geom::Matrix
+sp_gradient_get_gs2d_matrix(SPGradient const *gr, Geom::Matrix const &ctm, Geom::Rect const &bbox)
 {
-    if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
+    if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
         return ( gr->gradientTransform
-                 * NR::scale(bbox.dimensions())
-                 * NR::translate(bbox.min())
-                 * ctm );
+                 * Geom::Scale(bbox.dimensions())
+                 * Geom::Translate(bbox.min())
+                 * Geom::Matrix(ctm) );
     } else {
         return gr->gradientTransform * ctm;
     }
 }
 
 void
-sp_gradient_set_gs2d_matrix(SPGradient *gr, NR::Matrix const &ctm,
-                            NR::Rect const &bbox, NR::Matrix const &gs2d)
+sp_gradient_set_gs2d_matrix(SPGradient *gr, Geom::Matrix const &ctm,
+                            Geom::Rect const &bbox, Geom::Matrix const &gs2d)
 {
-    gr->gradientTransform = gs2d / ctm;
-    if ( gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
+    gr->gradientTransform = gs2d * ctm.inverse();
+    if (gr->getUnits() == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX ) {
         gr->gradientTransform = ( gr->gradientTransform
-                                  / NR::translate(bbox.min())
-                                  / NR::scale(bbox.dimensions()) );
+                                  * Geom::Translate(-bbox.min())
+                                  * Geom::Scale(bbox.dimensions()).inverse() );
     }
     gr->gradientTransform_set = TRUE;
 
@@ -1251,6 +1442,11 @@ struct SPLGPainter {
     SPLinearGradient *lg;
 
     NRLGradientRenderer lgr;
+
+    static SPPainter * painter_new(SPPaintServer *ps,
+                                   Geom::Matrix const &full_transform,
+                                   Geom::Matrix const &parent_transform,
+                                   NRRect const *bbox);
 };
 
 static void sp_lineargradient_class_init(SPLinearGradientClass *klass);
@@ -1260,13 +1456,9 @@ static void sp_lineargradient_build(SPObject *object,
                                     SPDocument *document,
                                     Inkscape::XML::Node *repr);
 static void sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr,
+static Inkscape::XML::Node *sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
                                                     guint flags);
 
-static SPPainter *sp_lineargradient_painter_new(SPPaintServer *ps,
-                                                NR::Matrix const &full_transform,
-                                                NR::Matrix const &parent_transform,
-                                                NRRect const *bbox);
 static void sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter);
 
 static void sp_lg_fill(SPPainter *painter, NRPixBlock *pb);
@@ -1310,7 +1502,7 @@ static void sp_lineargradient_class_init(SPLinearGradientClass *klass)
     sp_object_class->set = sp_lineargradient_set;
     sp_object_class->write = sp_lineargradient_write;
 
-    ps_class->painter_new = sp_lineargradient_painter_new;
+    ps_class->painter_new = SPLGPainter::painter_new;
     ps_class->painter_free = sp_lineargradient_painter_free;
 }
 
@@ -1320,9 +1512,9 @@ static void sp_lineargradient_class_init(SPLinearGradientClass *klass)
 static void sp_lineargradient_init(SPLinearGradient *lg)
 {
     lg->x1.unset(SVGLength::PERCENT, 0.0, 0.0);
-    lg->y1.unset(SVGLength::PERCENT, 0.5, 0.5);
+    lg->y1.unset(SVGLength::PERCENT, 0.0, 0.0);
     lg->x2.unset(SVGLength::PERCENT, 1.0, 1.0);
-    lg->y2.unset(SVGLength::PERCENT, 0.5, 0.5);
+    lg->y2.unset(SVGLength::PERCENT, 0.0, 0.0);
 }
 
 /**
@@ -1335,10 +1527,10 @@ static void sp_lineargradient_build(SPObject *object,
     if (((SPObjectClass *) lg_parent_class)->build)
         (* ((SPObjectClass *) lg_parent_class)->build)(object, document, repr);
 
-    sp_object_read_attr(object, "x1");
-    sp_object_read_attr(object, "y1");
-    sp_object_read_attr(object, "x2");
-    sp_object_read_attr(object, "y2");
+    object->readAttr( "x1" );
+    object->readAttr( "y1" );
+    object->readAttr( "x2" );
+    object->readAttr( "y2" );
 }
 
 /**
@@ -1355,7 +1547,7 @@ sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         case SP_ATTR_Y1:
-            lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.5, 0.5);
+            lg->y1.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         case SP_ATTR_X2:
@@ -1363,7 +1555,7 @@ sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         case SP_ATTR_Y2:
-            lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.5, 0.5);
+            lg->y2.readOrUnset(value, SVGLength::PERCENT, 0.0, 0.0);
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         default:
@@ -1377,12 +1569,12 @@ sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
  * Callback: write attributes to associated repr.
  */
 static Inkscape::XML::Node *
-sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
-        repr = sp_repr_new("svg:linearGradient");
+        repr = xml_doc->createElement("svg:linearGradient");
     }
 
     if ((flags & SP_OBJECT_WRITE_ALL) || lg->x1._set)
@@ -1395,14 +1587,14 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 
     if (((SPObjectClass *) lg_parent_class)->write)
-        (* ((SPObjectClass *) lg_parent_class)->write)(object, repr, flags);
+        (* ((SPObjectClass *) lg_parent_class)->write)(object, xml_doc, repr, flags);
 
     return repr;
 }
 
 /**
  * Create linear gradient context.
- * 
+ *
  * Basically we have to deal with transformations
  *
  * 1) color2norm - maps point in (0,NCOLORS) vector to (0,1) vector
@@ -1410,22 +1602,23 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
  * 2) gradientTransform
  * 3) bbox2user
  * 4) ctm == userspace to pixel grid
- * 
+ *
  * See also (*) in sp-pattern about why we may need parent_transform.
- * 
- * \todo (point 1 above) fixme: I do not know how to deal with start > 0 
+ *
+ * \todo (point 1 above) fixme: I do not know how to deal with start > 0
  * and end < 1.
  */
-static SPPainter *
-sp_lineargradient_painter_new(SPPaintServer *ps,
-                              NR::Matrix const &full_transform,
-                              NR::Matrix const &parent_transform,
-                              NRRect const *bbox)
+SPPainter * SPLGPainter::painter_new(SPPaintServer *ps,
+                                     Geom::Matrix const &full_transform,
+                                     Geom::Matrix const &/*parent_transform*/,
+                                     NRRect const *bbox)
 {
     SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
     SPGradient *gr = SP_GRADIENT(ps);
 
-    if (!gr->color) sp_gradient_ensure_colors(gr);
+    if (!gr->color) {
+        gr->ensureColors();
+    }
 
     SPLGPainter *lgp = g_new(SPLGPainter, 1);
 
@@ -1435,40 +1628,38 @@ sp_lineargradient_painter_new(SPPaintServer *ps,
     lgp->lg = lg;
 
     /** \todo
-     * Technically speaking, we map NCOLORS on line [start,end] onto line 
-     * [0,1].  I almost think we should fill color array start and end in 
-     * that case. The alternative would be to leave these just empty garbage 
-     * or something similar. Originally I had 1023.9999 here - not sure 
+     * Technically speaking, we map NCOLORS on line [start,end] onto line
+     * [0,1].  I almost think we should fill color array start and end in
+     * that case. The alternative would be to leave these just empty garbage
+     * or something similar. Originally I had 1023.9999 here - not sure
      * whether we have really to cut out ceil int (Lauris).
      */
-    NR::Matrix color2norm(NR::identity());
-    NR::Matrix color2px;
+    Geom::Matrix color2norm(Geom::identity());
+    Geom::Matrix color2px;
     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
-        NR::Matrix norm2pos(NR::identity());
+        Geom::Matrix norm2pos(Geom::identity());
 
         /* BBox to user coordinate system */
-        NR::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
+        Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
 
-        NR::Matrix color2pos = color2norm * norm2pos;
-        NR::Matrix color2tpos = color2pos * gr->gradientTransform;
-        NR::Matrix color2user = color2tpos * bbox2user;
+        Geom::Matrix color2pos = color2norm * norm2pos;
+        Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
+        Geom::Matrix color2user = color2tpos * bbox2user;
         color2px = color2user * full_transform;
 
     } else {
         /* Problem: What to do, if we have mixed lengths and percentages? */
         /* Currently we do ignore percentages at all, but that is not good (lauris) */
 
-        NR::Matrix norm2pos(NR::identity());
-        NR::Matrix color2pos = color2norm * norm2pos;
-        NR::Matrix color2tpos = color2pos * gr->gradientTransform;
+        Geom::Matrix norm2pos(Geom::identity());
+        Geom::Matrix color2pos = color2norm * norm2pos;
+        Geom::Matrix color2tpos = color2pos * gr->gradientTransform;
         color2px = color2tpos * full_transform;
 
     }
-
-    NRMatrix v2px;
-    color2px.copyto(&v2px);
-
-    nr_lgradient_renderer_setup(&lgp->lgr, gr->color, sp_gradient_get_spread(gr), &v2px,
+    // TODO: remove color2px_nr after converting to 2geom
+    NR::Matrix color2px_nr = from_2geom(color2px);
+    nr_lgradient_renderer_setup(&lgp->lgr, gr->color, gr->fetchSpread(), &color2px_nr,
                                 lg->x1.computed, lg->y1.computed,
                                 lg->x2.computed, lg->y2.computed);
 
@@ -1476,7 +1667,7 @@ sp_lineargradient_painter_new(SPPaintServer *ps,
 }
 
 static void
-sp_lineargradient_painter_free(SPPaintServer *ps, SPPainter *painter)
+sp_lineargradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
 {
     g_free(painter);
 }
@@ -1510,7 +1701,7 @@ sp_lg_fill(SPPainter *painter, NRPixBlock *pb)
     SPLGPainter *lgp = (SPLGPainter *) painter;
 
     if (lgp->lg->color == NULL) {
-        sp_gradient_ensure_colors (lgp->lg);
+        lgp->lg->ensureColors();
         lgp->lgr.vector = lgp->lg->color;
     }
 
@@ -1528,6 +1719,11 @@ struct SPRGPainter {
     SPPainter painter;
     SPRadialGradient *rg;
     NRRGradientRenderer rgr;
+
+    static SPPainter *painter_new(SPPaintServer *ps,
+                                  Geom::Matrix const &full_transform,
+                                  Geom::Matrix const &parent_transform,
+                                  NRRect const *bbox);
 };
 
 static void sp_radialgradient_class_init(SPRadialGradientClass *klass);
@@ -1537,13 +1733,8 @@ static void sp_radialgradient_build(SPObject *object,
                                     SPDocument *document,
                                     Inkscape::XML::Node *repr);
 static void sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr,
+static Inkscape::XML::Node *sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr,
                                                     guint flags);
-
-static SPPainter *sp_radialgradient_painter_new(SPPaintServer *ps,
-                                                NR::Matrix const &full_transform,
-                                                NR::Matrix const &parent_transform,
-                                                NRRect const *bbox);
 static void sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter);
 
 static void sp_rg_fill(SPPainter *painter, NRPixBlock *pb);
@@ -1587,7 +1778,7 @@ static void sp_radialgradient_class_init(SPRadialGradientClass *klass)
     sp_object_class->set = sp_radialgradient_set;
     sp_object_class->write = sp_radialgradient_write;
 
-    ps_class->painter_new = sp_radialgradient_painter_new;
+    ps_class->painter_new = SPRGPainter::painter_new;
     ps_class->painter_free = sp_radialgradient_painter_free;
 }
 
@@ -1613,11 +1804,11 @@ sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::N
     if (((SPObjectClass *) rg_parent_class)->build)
         (* ((SPObjectClass *) rg_parent_class)->build)(object, document, repr);
 
-    sp_object_read_attr(object, "cx");
-    sp_object_read_attr(object, "cy");
-    sp_object_read_attr(object, "r");
-    sp_object_read_attr(object, "fx");
-    sp_object_read_attr(object, "fy");
+    object->readAttr( "cx" );
+    object->readAttr( "cy" );
+    object->readAttr( "r" );
+    object->readAttr( "fx" );
+    object->readAttr( "fy" );
 }
 
 /**
@@ -1678,12 +1869,12 @@ sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
  * Write radial gradient attributes to associated repr.
  */
 static Inkscape::XML::Node *
-sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
-        repr = sp_repr_new("svg:radialGradient");
+        repr = xml_doc->createElement("svg:radialGradient");
     }
 
     if ((flags & SP_OBJECT_WRITE_ALL) || rg->cx._set) sp_repr_set_svg_double(repr, "cx", rg->cx.computed);
@@ -1693,7 +1884,7 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fy._set) sp_repr_set_svg_double(repr, "fy", rg->fy.computed);
 
     if (((SPObjectClass *) rg_parent_class)->write)
-        (* ((SPObjectClass *) rg_parent_class)->write)(object, repr, flags);
+        (* ((SPObjectClass *) rg_parent_class)->write)(object, xml_doc, repr, flags);
 
     return repr;
 }
@@ -1701,16 +1892,17 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
 /**
  * Create radial gradient context.
  */
-static SPPainter *
-sp_radialgradient_painter_new(SPPaintServer *ps,
-                              NR::Matrix const &full_transform,
-                              NR::Matrix const &parent_transform,
-                              NRRect const *bbox)
+SPPainter *SPRGPainter::painter_new(SPPaintServer *ps,
+                                    Geom::Matrix const &full_transform,
+                                    Geom::Matrix const &/*parent_transform*/,
+                                    NRRect const *bbox)
 {
     SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
     SPGradient *gr = SP_GRADIENT(ps);
 
-    if (!gr->color) sp_gradient_ensure_colors(gr);
+    if (!gr->color) {
+        gr->ensureColors();
+    }
 
     SPRGPainter *rgp = g_new(SPRGPainter, 1);
 
@@ -1719,34 +1911,32 @@ sp_radialgradient_painter_new(SPPaintServer *ps,
 
     rgp->rg = rg;
 
-    NR::Matrix gs2px;
+    Geom::Matrix gs2px;
 
     if (gr->units == SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX) {
         /** \todo
-         * fixme: We may try to normalize here too, look at 
+         * fixme: We may try to normalize here too, look at
          * linearGradient (Lauris)
          */
 
         /* BBox to user coordinate system */
-        NR::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
+        Geom::Matrix bbox2user(bbox->x1 - bbox->x0, 0, 0, bbox->y1 - bbox->y0, bbox->x0, bbox->y0);
 
-        NR::Matrix gs2user = gr->gradientTransform * bbox2user;
+        Geom::Matrix gs2user = gr->gradientTransform * bbox2user;
 
         gs2px = gs2user * full_transform;
     } else {
         /** \todo
          * Problem: What to do, if we have mixed lengths and percentages?
-         * Currently we do ignore percentages at all, but that is not 
+         * Currently we do ignore percentages at all, but that is not
          * good (lauris)
          */
 
         gs2px = gr->gradientTransform * full_transform;
     }
-
-    NRMatrix gs2px_nr;
-    gs2px.copyto(&gs2px_nr);
-
-    nr_rgradient_renderer_setup(&rgp->rgr, gr->color, sp_gradient_get_spread(gr),
+    // TODO: remove gs2px_nr after converting to 2geom
+    NR::Matrix gs2px_nr = from_2geom(gs2px);
+    nr_rgradient_renderer_setup(&rgp->rgr, gr->color, gr->fetchSpread(),
                                 &gs2px_nr,
                                 rg->cx.computed, rg->cy.computed,
                                 rg->fx.computed, rg->fy.computed,
@@ -1756,7 +1946,7 @@ sp_radialgradient_painter_new(SPPaintServer *ps,
 }
 
 static void
-sp_radialgradient_painter_free(SPPaintServer *ps, SPPainter *painter)
+sp_radialgradient_painter_free(SPPaintServer */*ps*/, SPPainter *painter)
 {
     g_free(painter);
 }
@@ -1790,7 +1980,7 @@ sp_rg_fill(SPPainter *painter, NRPixBlock *pb)
     SPRGPainter *rgp = (SPRGPainter *) painter;
 
     if (rgp->rg->color == NULL) {
-        sp_gradient_ensure_colors (rgp->rg);
+        rgp->rg->ensureColors();
         rgp->rgr.vector = rgp->rg->color;
     }
 
@@ -1806,4 +1996,4 @@ sp_rg_fill(SPPainter *painter, NRPixBlock *pb)
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :