Added "virtual pad" to

 - SPPaintServer
 - SPPattern
 - SPGradient
 - SPStop
 - SPLinearGradient
 - SPMeshGradient
 - SPMeshPatch
 - SPMeshRow
 - SPRadialGradient

As all subclasses of SPPaintServer now have "virtual pads" with correct inheritance, the virtual function call to "onCreatePattern" was converted to C++ style.

(bzr r11608.1.35)

12 files changed, 652 insertions, 219 deletions

diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index 262c35db1..778d6e52e 100644
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
@@ -93,28 +93,7 @@ static Inkscape::XML::Node *sp_meshpatch_write(SPObject *object, Inkscape::XML::
 static SPObjectClass *meshpatch_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.
@@ -153,25 +132,32 @@ static void sp_stop_class_init(SPStopClass *klass)
     sp_object_class->write = sp_stop_write;
 }
 
+CStop::CStop(SPStop* stop) : CObject(stop) {
+	this->spstop = stop;
+}
+
+CStop::~CStop() {
+}
+
 /**
  * Callback to initialize SPStop object.
  */
 static void
 sp_stop_init(SPStop *stop)
 {
+	stop->cstop = new CStop(stop);
+	stop->cobject = stop->cstop;
+
     stop->offset = 0.0;
     stop->currentColor = false;
     stop->specified_color.set( 0x000000ff );
     stop->opacity = 1.0;
 }
 
-/**
- * Virtual build: set stop attributes from its associated XML node.
- */
-static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
-    if (((SPObjectClass *) stop_parent_class)->build)
-        (* ((SPObjectClass *) stop_parent_class)->build)(object, document, repr);
+void CStop::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) {
+	SPStop* object = this->spstop;
+
+    CObject::onBuild(doc, repr);
 
     object->readAttr( "offset" );
     object->readAttr( "stop-color" );
@@ -181,11 +167,16 @@ static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML:
 }
 
 /**
- * Virtual set: set attribute to value.
+ * Virtual build: set stop attributes from its associated XML node.
  */
-static void
-sp_stop_set(SPObject *object, unsigned key, gchar const *value)
+static void sp_stop_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
+	((SPStop*)object)->cstop->onBuild(document, repr);
+}
+
+void CStop::onSet(unsigned int key, const gchar* value) {
+	SPStop* object = this->spstop;
+
     SPStop *stop = SP_STOP(object);
 
     switch (key) {
@@ -256,19 +247,24 @@ sp_stop_set(SPObject *object, unsigned key, gchar const *value)
             break;
         }
         default: {
-            if (((SPObjectClass *) stop_parent_class)->set)
-                (* ((SPObjectClass *) stop_parent_class)->set)(object, key, value);
+            CObject::onSet(key, value);
             break;
         }
     }
 }
 
 /**
- * Virtual write: write object attributes to repr.
+ * Virtual set: set attribute to value.
  */
-static Inkscape::XML::Node *
-sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+static void
+sp_stop_set(SPObject *object, unsigned key, gchar const *value)
 {
+	((SPStop*)object)->cstop->onSet(key, value);
+}
+
+Inkscape::XML::Node* CStop::onWrite(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) {
+	SPStop* object = this->spstop;
+
     SPStop *stop = SP_STOP(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
@@ -278,9 +274,7 @@ sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
     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);
-    }
+    CObject::onWrite(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
@@ -304,6 +298,15 @@ sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML:
     return repr;
 }
 
+/**
+ * Virtual write: write object attributes to repr.
+ */
+static Inkscape::XML::Node *
+sp_stop_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPStop*)object)->cstop->onWrite(xml_doc, repr, flags);
+}
+
 
 bool SPGradient::hasStops() const
 {
@@ -411,12 +414,24 @@ static void sp_meshrow_class_init(SPMeshRowClass *klass)
     sp_object_class->write = sp_meshrow_write;
 }
 
+CMeshRow::CMeshRow(SPMeshRow* meshrow) : CObject(meshrow) {
+	this->spmeshrow = meshrow;
+}
+
+CMeshRow::~CMeshRow() {
+}
+
 /**
  * Callback to initialize SPMeshRow object.
  */
-static void sp_meshrow_init(SPMeshRow * /*meshrow*/)
+static void sp_meshrow_init(SPMeshRow * meshrow)
 {
-    // Do nothing
+    meshrow->cmeshrow = new CMeshRow(meshrow);
+    meshrow->cobject = meshrow->cmeshrow;
+}
+
+void CMeshRow::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) {
+	CObject::onBuild(doc, repr);
 }
 
 /**
@@ -424,10 +439,11 @@ static void sp_meshrow_init(SPMeshRow * /*meshrow*/)
  */
 static void sp_meshrow_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
-    if (((SPObjectClass *) meshrow_parent_class)->build)
-        (* ((SPObjectClass *) meshrow_parent_class)->build)(object, document, repr);
+	((SPMeshRow*)object)->cmeshrow->onBuild(document, repr);
+}
+
+void CMeshRow::onSet(unsigned int key, const gchar* value) {
 
-    // No attributes
 }
 
 /**
@@ -438,25 +454,25 @@ static void sp_meshrow_set(SPObject * /*object*/, unsigned /*key*/, gchar const
     // Do nothing
 }
 
-/**
- * Virtual write: write object attributes to repr.
- */
-static Inkscape::XML::Node *
-sp_meshrow_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
-{
-    //SPMeshRow *meshrow = SP_MESHROW(object);
-
+Inkscape::XML::Node* CMeshRow::onWrite(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) {
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
         repr = xml_doc->createElement("svg:meshRow");
     }
 
-    if (((SPObjectClass *) meshrow_parent_class)->write) {
-        (* ((SPObjectClass *) meshrow_parent_class)->write)(object, xml_doc, repr, flags);
-    }
+    CObject::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
+/**
+ * Virtual write: write object attributes to repr.
+ */
+static Inkscape::XML::Node *
+sp_meshrow_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPMeshRow*)object)->cmeshrow->onWrite(xml_doc, repr, flags);
+}
+
 /*
  * Mesh Patch
  */
@@ -498,12 +514,28 @@ static void sp_meshpatch_class_init(SPMeshPatchClass *klass)
     sp_object_class->write = sp_meshpatch_write;
 }
 
+CMeshPatch::CMeshPatch(SPMeshPatch* meshpatch) : CObject(meshpatch) {
+	this->spmeshpatch = meshpatch;
+}
+
+CMeshPatch::~CMeshPatch() {
+}
+
 /**
  * Callback to initialize SPMeshPatch object.
  */
-static void sp_meshpatch_init(SPMeshPatch * /*meshpatch*/)
+static void sp_meshpatch_init(SPMeshPatch * meshpatch)
 {
-    // Do nothing
+    meshpatch->cmeshpatch = new CMeshPatch(meshpatch);
+    meshpatch->cobject = meshpatch->cmeshpatch;
+}
+
+void CMeshPatch::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) {
+	SPMeshPatch* object = this->spmeshpatch;
+
+	CObject::onBuild(doc, repr);
+
+	object->readAttr( "tensor" );
 }
 
 /**
@@ -511,18 +543,12 @@ static void sp_meshpatch_init(SPMeshPatch * /*meshpatch*/)
  */
 static void sp_meshpatch_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
-    if (((SPObjectClass *) meshpatch_parent_class)->build)
-        (* ((SPObjectClass *) meshpatch_parent_class)->build)(object, document, repr);
-
-    object->readAttr( "tensor" );
+	((SPMeshPatch*)object)->cmeshpatch->onBuild(document, repr);
 }
 
-/**
- * Virtual set: set attribute to value.
- */
-static void
-sp_meshpatch_set(SPObject *object, unsigned key, gchar const *value)
-{
+void CMeshPatch::onSet(unsigned int key, const gchar* value) {
+	SPMeshPatch* object = this->spmeshpatch;
+
     SPMeshPatch *patch = SP_MESHPATCH(object);
 
     switch (key) {
@@ -540,24 +566,33 @@ sp_meshpatch_set(SPObject *object, unsigned key, gchar const *value)
 }
 
 /**
- * Virtual write: write object attributes to repr.
+ * Virtual set: set attribute to value.
  */
-static Inkscape::XML::Node *
-sp_meshpatch_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+static void
+sp_meshpatch_set(SPObject *object, unsigned key, gchar const *value)
 {
-    //SPMeshPatch *meshpatch = SP_MESHPATCH(object);
+	((SPMeshPatch*)object)->cmeshpatch->onSet(key, value);
+}
 
+Inkscape::XML::Node* CMeshPatch::onWrite(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) {
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
         repr = xml_doc->createElement("svg:meshPatch");
     }
 
-    if (((SPObjectClass *) meshpatch_parent_class)->write) {
-        (* ((SPObjectClass *) meshpatch_parent_class)->write)(object, xml_doc, repr, flags);
-    }
+    CObject::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
+/**
+ * Virtual write: write object attributes to repr.
+ */
+static Inkscape::XML::Node *
+sp_meshpatch_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPMeshPatch*)object)->cmeshpatch->onWrite(xml_doc, repr, flags);
+}
+
 
 /*
  * Gradient
@@ -576,11 +611,11 @@ GType SPGradient::getType()
         GTypeInfo gradient_info = {
             sizeof(SPGradientClass),
             NULL, NULL,
-            (GClassInitFunc) SPGradientImpl::classInit,
+            (GClassInitFunc) CGradient::classInit,
             NULL, NULL,
             sizeof(SPGradient),
             16,
-            (GInstanceInitFunc) SPGradientImpl::init,
+            (GInstanceInitFunc) CGradient::init,
             NULL,   /* value_table */
         };
         gradient_type = g_type_register_static(SP_TYPE_PAINT_SERVER, "SPGradient",
@@ -589,31 +624,51 @@ GType SPGradient::getType()
     return gradient_type;
 }
 
+void spgradient_on_build(SPObject* object, SPDocument *document, Inkscape::XML::Node *repr);
+void spgradient_on_release(SPObject* object);
+void spgradient_set(SPObject* object, unsigned int key, const gchar* value);
+void spgradient_child_added(SPObject* object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
+void spgradient_remove_child(SPObject* object, Inkscape::XML::Node *child);
+void spgradient_modified(SPObject* object, guint flags);
+Inkscape::XML::Node* spgradient_write(SPObject* object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+
+
 /**
  * SPGradient vtable initialization.
  */
-void SPGradientImpl::classInit(SPGradientClass *klass)
+void CGradient::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 = 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;
+    sp_object_class->build = spgradient_on_build;
+    sp_object_class->release = spgradient_on_release;
+    sp_object_class->set = spgradient_set;
+    sp_object_class->child_added = spgradient_child_added;
+    sp_object_class->remove_child = spgradient_remove_child;
+    sp_object_class->modified = spgradient_modified;
+    sp_object_class->write = spgradient_write;
+}
+
+CGradient::CGradient(SPGradient* gradient) : CPaintServer(gradient) {
+	this->spgradient = gradient;
+}
+
+CGradient::~CGradient() {
 }
 
 /**
  * Callback for SPGradient object initialization.
  */
-void SPGradientImpl::init(SPGradient *gr)
+void CGradient::init(SPGradient *gr)
 {
+	gr->cgradient = new CGradient(gr);
+	gr->cpaintserver = gr->cgradient;
+	gr->cobject = gr->cgradient;
+
     gr->ref = new SPGradientReference(gr);
-    gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(SPGradientImpl::gradientRefChanged), gr));
+    gr->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(CGradient::gradientRefChanged), gr));
 
     /** \todo
      * Fixme: reprs being rearranged (e.g. via the XML editor)
@@ -641,8 +696,9 @@ void SPGradientImpl::init(SPGradient *gr)
 /**
  * Virtual build: set gradient attributes from its associated repr.
  */
-void SPGradientImpl::build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+void CGradient::onBuild(SPDocument *document, Inkscape::XML::Node *repr)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gradient = SP_GRADIENT(object);
 
     // Work-around in case a swatch had been marked for immediate collection:
@@ -650,9 +706,7 @@ void SPGradientImpl::build(SPObject *object, SPDocument *document, Inkscape::XML
         repr->setAttribute("inkscape:collect", 0);
     }
 
-    if (((SPObjectClass *) gradient_parent_class)->build) {
-        (* ((SPObjectClass *) gradient_parent_class)->build)(object, document, repr);
-    }
+    CPaintServer::onBuild(document, repr);
 
     for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
         if (SP_IS_STOP(ochild)) {
@@ -671,11 +725,16 @@ void SPGradientImpl::build(SPObject *object, SPDocument *document, Inkscape::XML
     document->addResource("gradient", object);
 }
 
+void spgradient_on_build(SPObject* object, SPDocument *document, Inkscape::XML::Node *repr) {
+	((SPGradient*)object)->cgradient->onBuild(document, repr);
+}
+
 /**
  * Virtual release of SPGradient members before destruction.
  */
-void SPGradientImpl::release(SPObject *object)
+void CGradient::onRelease()
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gradient = (SPGradient *) object;
 
 #ifdef SP_GRADIENT_VERBOSE
@@ -696,15 +755,19 @@ void SPGradientImpl::release(SPObject *object)
 
     gradient->modified_connection.~connection();
 
-    if (((SPObjectClass *) gradient_parent_class)->release)
-        ((SPObjectClass *) gradient_parent_class)->release(object);
+    CPaintServer::onRelease();
+}
+
+void spgradient_on_release(SPObject* object) {
+	((SPGradient*)object)->cgradient->onRelease();
 }
 
 /**
  * Set gradient attribute to value.
  */
-void SPGradientImpl::setGradientAttr(SPObject *object, unsigned key, gchar const *value)
+void CGradient::onSet(unsigned key, gchar const *value)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gr = SP_GRADIENT(object);
 
     switch (key) {
@@ -783,17 +846,19 @@ void SPGradientImpl::setGradientAttr(SPObject *object, unsigned key, gchar const
         }
             break;
         default:
-            if (((SPObjectClass *) gradient_parent_class)->set) {
-                ((SPObjectClass *) gradient_parent_class)->set(object, key, value);
-            }
+            CPaintServer::onSet(key, value);
             break;
     }
 }
 
+void spgradient_set(SPObject* object, unsigned int key, const gchar* value) {
+	((SPGradient*)object)->cgradient->onSet(key, value);
+}
+
 /**
  * Gets called when the gradient is (re)attached to another gradient.
  */
-void SPGradientImpl::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr)
+void CGradient::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGradient *gr)
 {
     if (old_ref) {
         gr->modified_connection.disconnect();
@@ -801,7 +866,7 @@ void SPGradientImpl::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGrad
     if ( SP_IS_GRADIENT(ref)
          && ref != gr )
     {
-        gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&SPGradientImpl::gradientRefModified), gr));
+        gr->modified_connection = ref->connectModified(sigc::bind<2>(sigc::ptr_fun(&CGradient::gradientRefModified), gr));
     }
 
     // Per SVG, all unset attributes must be inherited from linked gradient.
@@ -822,15 +887,14 @@ void SPGradientImpl::gradientRefChanged(SPObject *old_ref, SPObject *ref, SPGrad
 /**
  * Callback for child_added event.
  */
-void SPGradientImpl::childAdded(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
+void CGradient::onChildAdded(Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gr = SP_GRADIENT(object);
 
     gr->invalidateVector();
 
-    if (((SPObjectClass *) gradient_parent_class)->child_added) {
-        (* ((SPObjectClass *) gradient_parent_class)->child_added)(object, child, ref);
-    }
+    CPaintServer::onChildAdded(child, ref);
 
     SPObject *ochild = object->get_child_by_repr(child);
     if ( ochild && SP_IS_STOP(ochild) ) {
@@ -847,18 +911,21 @@ void SPGradientImpl::childAdded(SPObject *object, Inkscape::XML::Node *child, In
     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
 
+void spgradient_child_added(SPObject* object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref) {
+	((SPGradient*)object)->cgradient->onChildAdded(child, ref);
+}
+
 /**
  * Callback for remove_child event.
  */
-void SPGradientImpl::removeChild(SPObject *object, Inkscape::XML::Node *child)
+void CGradient::onRemoveChild(Inkscape::XML::Node *child)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gr = SP_GRADIENT(object);
 
     gr->invalidateVector();
 
-    if (((SPObjectClass *) gradient_parent_class)->remove_child) {
-        (* ((SPObjectClass *) gradient_parent_class)->remove_child)(object, child);
-    }
+    CPaintServer::onRemoveChild(child);
 
     gr->has_stops = FALSE;
     for ( SPObject *ochild = object->firstChild() ; ochild ; ochild = ochild->getNext() ) {
@@ -879,11 +946,16 @@ void SPGradientImpl::removeChild(SPObject *object, Inkscape::XML::Node *child)
     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
 
+void spgradient_remove_child(SPObject* object, Inkscape::XML::Node *child) {
+	((SPGradient*)object)->cgradient->onRemoveChild(child);
+}
+
 /**
  * Callback for modified event.
  */
-void SPGradientImpl::modified(SPObject *object, guint flags)
+void CGradient::onModified(guint flags)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gr = SP_GRADIENT(object);
 
     if (flags & SP_OBJECT_CHILD_MODIFIED_FLAG) {
@@ -922,6 +994,10 @@ void SPGradientImpl::modified(SPObject *object, guint flags)
     }
 }
 
+void spgradient_modified(SPObject* object, guint flags) {
+	((SPGradient*)object)->cgradient->onModified(flags);
+}
+
 SPStop* SPGradient::getFirstStop()
 {
     SPStop* first = 0;
@@ -947,13 +1023,12 @@ int SPGradient::getStopCount() const
 /**
  * Write gradient attributes to repr.
  */
-Inkscape::XML::Node *SPGradientImpl::write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+Inkscape::XML::Node *CGradient::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
+	SPGradient* object = this->spgradient;
     SPGradient *gr = SP_GRADIENT(object);
 
-    if (((SPObjectClass *) gradient_parent_class)->write) {
-        (* ((SPObjectClass *) gradient_parent_class)->write)(object, xml_doc, repr, flags);
-    }
+    CPaintServer::onWrite(xml_doc, repr, flags);
 
     if (flags & SP_OBJECT_WRITE_BUILD) {
         GSList *l = NULL;
@@ -1023,6 +1098,10 @@ Inkscape::XML::Node *SPGradientImpl::write(SPObject *object, Inkscape::XML::Docu
     return repr;
 }
 
+Inkscape::XML::Node* spgradient_write(SPObject* object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	return ((SPGradient*)object)->cgradient->onWrite(xml_doc, repr, flags);
+}
+
 /**
  * Forces the vector to be built, if not present (i.e., changed).
  *
@@ -1243,7 +1322,7 @@ sp_gradient_repr_write_vector(SPGradient *gr)
 }
 
 
-void SPGradientImpl::gradientRefModified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
+void CGradient::gradientRefModified(SPObject */*href*/, guint /*flags*/, SPGradient *gradient)
 {
     if ( gradient->invalidateVector() ) {
         gradient->requestModified(SP_OBJECT_MODIFIED_FLAG);
@@ -1514,26 +1593,33 @@ static void sp_lineargradient_class_init(SPLinearGradientClass *klass)
     ps_class->pattern_new = sp_lineargradient_create_pattern;
 }
 
+CLinearGradient::CLinearGradient(SPLinearGradient* lineargradient) : CGradient(lineargradient) {
+	this->splineargradient = lineargradient;
+}
+
+CLinearGradient::~CLinearGradient() {
+}
+
 /**
  * Callback for SPLinearGradient object initialization.
  */
 static void sp_lineargradient_init(SPLinearGradient *lg)
 {
+	lg->clineargradient = new CLinearGradient(lg);
+	lg->cgradient = lg->clineargradient;
+	lg->cpaintserver = lg->clineargradient;
+	lg->cobject = lg->clineargradient;
+
     lg->x1.unset(SVGLength::PERCENT, 0.0, 0.0);
     lg->y1.unset(SVGLength::PERCENT, 0.0, 0.0);
     lg->x2.unset(SVGLength::PERCENT, 1.0, 1.0);
     lg->y2.unset(SVGLength::PERCENT, 0.0, 0.0);
 }
 
-/**
- * Callback: set attributes from associated repr.
- */
-static void sp_lineargradient_build(SPObject *object,
-                                    SPDocument *document,
-                                    Inkscape::XML::Node *repr)
-{
-    if (((SPObjectClass *) lg_parent_class)->build)
-        (* ((SPObjectClass *) lg_parent_class)->build)(object, document, repr);
+void CLinearGradient::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPLinearGradient* object = this->splineargradient;
+
+    CGradient::onBuild(document, repr);
 
     object->readAttr( "x1" );
     object->readAttr( "y1" );
@@ -1542,11 +1628,18 @@ static void sp_lineargradient_build(SPObject *object,
 }
 
 /**
- * Callback: set attribute.
+ * Callback: set attributes from associated repr.
  */
-static void
-sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
+static void sp_lineargradient_build(SPObject *object,
+                                    SPDocument *document,
+                                    Inkscape::XML::Node *repr)
 {
+	((SPLinearGradient*)object)->clineargradient->onBuild(document, repr);
+}
+
+void CLinearGradient::onSet(unsigned int key, const gchar* value) {
+	SPLinearGradient* object = this->splineargradient;
+
     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
 
     switch (key) {
@@ -1567,18 +1660,23 @@ sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         default:
-            if (((SPObjectClass *) lg_parent_class)->set)
-                (* ((SPObjectClass *) lg_parent_class)->set)(object, key, value);
+            CGradient::onSet(key, value);
             break;
     }
 }
 
 /**
- * Callback: write attributes to associated repr.
+ * Callback: set attribute.
  */
-static Inkscape::XML::Node *
-sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+static void
+sp_lineargradient_set(SPObject *object, unsigned key, gchar const *value)
 {
+	((SPLinearGradient*)object)->clineargradient->onSet(key, value);
+}
+
+Inkscape::XML::Node* CLinearGradient::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	SPLinearGradient* object = this->splineargradient;
+
     SPLinearGradient *lg = SP_LINEARGRADIENT(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
@@ -1594,13 +1692,21 @@ sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inks
     if ((flags & SP_OBJECT_WRITE_ALL) || lg->y2._set)
         sp_repr_set_svg_double(repr, "y2", lg->y2.computed);
 
-    if (((SPObjectClass *) lg_parent_class)->write)
-        (* ((SPObjectClass *) lg_parent_class)->write)(object, xml_doc, repr, flags);
+    CGradient::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
 /**
+ * Callback: write attributes to associated repr.
+ */
+static Inkscape::XML::Node *
+sp_lineargradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPLinearGradient*)object)->clineargradient->onWrite(xml_doc, repr, flags);
+}
+
+/**
  * Directly set properties of linear gradient and request modified.
  */
 void
@@ -1677,12 +1783,24 @@ static void sp_radialgradient_class_init(SPRadialGradientClass *klass)
     ps_class->pattern_new = sp_radialgradient_create_pattern;
 }
 
+CRadialGradient::CRadialGradient(SPRadialGradient* radialgradient) : CGradient(radialgradient) {
+	this->spradialgradient = radialgradient;
+}
+
+CRadialGradient::~CRadialGradient() {
+}
+
 /**
  * Callback for SPRadialGradient object initialization.
  */
 static void
 sp_radialgradient_init(SPRadialGradient *rg)
 {
+	rg->cradialgradient = new CRadialGradient(rg);
+	rg->cgradient = rg->cradialgradient;
+	rg->cpaintserver = rg->cradialgradient;
+	rg->cobject = rg->cradialgradient;
+
     rg->cx.unset(SVGLength::PERCENT, 0.5, 0.5);
     rg->cy.unset(SVGLength::PERCENT, 0.5, 0.5);
     rg->r.unset(SVGLength::PERCENT, 0.5, 0.5);
@@ -1690,14 +1808,10 @@ sp_radialgradient_init(SPRadialGradient *rg)
     rg->fy.unset(SVGLength::PERCENT, 0.5, 0.5);
 }
 
-/**
- * Set radial gradient attributes from associated repr.
- */
-static void
-sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
-    if (((SPObjectClass *) rg_parent_class)->build)
-        (* ((SPObjectClass *) rg_parent_class)->build)(object, document, repr);
+void CRadialGradient::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPRadialGradient* object = this->spradialgradient;
+
+    CGradient::onBuild(document, repr);
 
     object->readAttr( "cx" );
     object->readAttr( "cy" );
@@ -1707,11 +1821,17 @@ sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::N
 }
 
 /**
- * Set radial gradient attribute.
+ * Set radial gradient attributes from associated repr.
  */
 static void
-sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
+sp_radialgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
+	((SPRadialGradient*)object)->cradialgradient->onBuild(document, repr);
+}
+
+void CRadialGradient::onSet(unsigned key, gchar const *value) {
+	SPRadialGradient* object = this->spradialgradient;
+
     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
 
     switch (key) {
@@ -1754,18 +1874,23 @@ sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         default:
-            if (((SPObjectClass *) rg_parent_class)->set)
-                ((SPObjectClass *) rg_parent_class)->set(object, key, value);
+            CGradient::onSet(key, value);
             break;
     }
 }
 
 /**
- * Write radial gradient attributes to associated repr.
+ * Set radial gradient attribute.
  */
-static Inkscape::XML::Node *
-sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+static void
+sp_radialgradient_set(SPObject *object, unsigned key, gchar const *value)
 {
+	((SPRadialGradient*)object)->cradialgradient->onSet(key, value);
+}
+
+Inkscape::XML::Node* CRadialGradient::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	SPRadialGradient* object = this->spradialgradient;
+
     SPRadialGradient *rg = SP_RADIALGRADIENT(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
@@ -1778,13 +1903,21 @@ sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inks
     if ((flags & SP_OBJECT_WRITE_ALL) || rg->fx._set) sp_repr_set_svg_double(repr, "fx", rg->fx.computed);
     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, xml_doc, repr, flags);
+    CGradient::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
 /**
+ * Write radial gradient attributes to associated repr.
+ */
+static Inkscape::XML::Node *
+sp_radialgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPRadialGradient*)object)->cradialgradient->onWrite(xml_doc, repr, flags);
+}
+
+/**
  * Directly set properties of radial gradient and request modified.
  */
 void
@@ -1866,25 +1999,33 @@ static void sp_meshgradient_class_init(SPMeshGradientClass *klass)
     ps_class->pattern_new = sp_meshgradient_create_pattern;
 }
 
+CMeshGradient::CMeshGradient(SPMeshGradient* meshgradient) : CGradient(meshgradient) {
+	this->spmeshgradient = meshgradient;
+}
+
+CMeshGradient::~CMeshGradient() {
+}
+
 /**
  * Callback for SPMeshGradient object initialization.
  */
 static void
 sp_meshgradient_init(SPMeshGradient *mg)
 {
+	mg->cmeshgradient = new CMeshGradient(mg);
+	mg->cgradient = mg->cmeshgradient;
+	mg->cpaintserver = mg->cmeshgradient;
+	mg->cobject = mg->cmeshgradient;
+
     // Start coordinate of mesh
     mg->x.unset(SVGLength::NONE, 0.0, 0.0);
     mg->y.unset(SVGLength::NONE, 0.0, 0.0);
 }
 
-/**
- * Set mesh gradient attributes from associated repr.
- */
-static void
-sp_meshgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
-    if (((SPObjectClass *) mg_parent_class)->build)
-        (* ((SPObjectClass *) mg_parent_class)->build)(object, document, repr);
+void CMeshGradient::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPMeshGradient* object = this->spmeshgradient;
+
+    CGradient::onBuild(document, repr);
 
     // Start coordinate of mesh
     object->readAttr( "x" );
@@ -1892,11 +2033,17 @@ sp_meshgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Nod
 }
 
 /**
- * Set mesh gradient attribute.
+ * Set mesh gradient attributes from associated repr.
  */
 static void
-sp_meshgradient_set(SPObject *object, unsigned key, gchar const *value)
+sp_meshgradient_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
+	((SPMeshGradient*)object)->cmeshgradient->onBuild(document, repr);
+}
+
+void CMeshGradient::onSet(unsigned key, gchar const *value) {
+	SPMeshGradient* object = this->spmeshgradient;
+
     SPMeshGradient *mg = SP_MESHGRADIENT(object);
 
     switch (key) {
@@ -1913,18 +2060,22 @@ sp_meshgradient_set(SPObject *object, unsigned key, gchar const *value)
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
         default:
-            if (((SPObjectClass *) mg_parent_class)->set)
-                ((SPObjectClass *) mg_parent_class)->set(object, key, value);
+            CGradient::onSet(key, value);
             break;
     }
 }
 
 /**
- * Write mesh gradient attributes to associated repr.
+ * Set mesh gradient attribute.
  */
-static Inkscape::XML::Node *
-sp_meshgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+static void
+sp_meshgradient_set(SPObject *object, unsigned key, gchar const *value)
 {
+	((SPMeshGradient*)object)->cmeshgradient->onSet(key, value);
+}
+
+Inkscape::XML::Node* CMeshGradient::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	SPMeshGradient* object = this->spmeshgradient;
 
 #ifdef MESH_DEBUG
     std::cout << "sp_meshgradient_write() ***************************" << std::endl;
@@ -1938,13 +2089,21 @@ sp_meshgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inksca
     if ((flags & SP_OBJECT_WRITE_ALL) || mg->x._set) sp_repr_set_svg_double(repr, "x", mg->x.computed);
     if ((flags & SP_OBJECT_WRITE_ALL) || mg->y._set) sp_repr_set_svg_double(repr, "y", mg->y.computed);
 
-    if (((SPObjectClass *) mg_parent_class)->write)
-        (* ((SPObjectClass *) mg_parent_class)->write)(object, xml_doc, repr, flags);
+    CGradient::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
 /**
+ * Write mesh gradient attributes to associated repr.
+ */
+static Inkscape::XML::Node *
+sp_meshgradient_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPMeshGradient*)object)->cmeshgradient->onWrite(xml_doc, repr, flags);
+}
+
+/**
  * Directly set properties of mesh gradient and request modified.
  */
 void
@@ -1999,12 +2158,10 @@ sp_gradient_pattern_common_setup(cairo_pattern_t *cp,
     ink_cairo_pattern_set_matrix(cp, gs2user.inverse());
 }
 
-static cairo_pattern_t *
-sp_radialgradient_create_pattern(SPPaintServer *ps,
-                                 cairo_t *ct,
-                                 Geom::OptRect const &bbox,
-                                 double opacity)
-{
+
+cairo_pattern_t* CRadialGradient::onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity) {
+	SPRadialGradient* ps = this->spradialgradient;
+
     SPRadialGradient *rg = SP_RADIALGRADIENT(ps);
     SPGradient *gr = SP_GRADIENT(ps);
 
@@ -2040,8 +2197,18 @@ sp_radialgradient_create_pattern(SPPaintServer *ps,
     return cp;
 }
 
-static cairo_pattern_t *sp_meshgradient_create_pattern(SPPaintServer *ps,
-                                                       cairo_t * /* ct */,
+static cairo_pattern_t *
+sp_radialgradient_create_pattern(SPPaintServer *ps,
+                                 cairo_t *ct,
+                                 Geom::OptRect const &bbox,
+                                 double opacity)
+{
+	return ((SPRadialGradient*)ps)->cradialgradient->onCreatePattern(ct, bbox, opacity);
+}
+
+
+
+cairo_pattern_t* CMeshGradient::onCreatePattern(cairo_t *ct,
 #if defined(MESH_DEBUG) || (CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 11, 4))
                                                        Geom::OptRect const &bbox,
                                                        double opacity
@@ -2054,6 +2221,8 @@ static cairo_pattern_t *sp_meshgradient_create_pattern(SPPaintServer *ps,
     using Geom::X;
     using Geom::Y;
 
+    SPMeshGradient* ps = this->spmeshgradient;
+
 #ifdef MESH_DEBUG
     std::cout << "sp_meshgradient_create_pattern: (" << bbox->x0 << "," <<  bbox->y0 << ") (" <<  bbox->x1 << "," << bbox->y1 << ")  " << opacity << std::endl;
 #endif
@@ -2163,12 +2332,13 @@ static cairo_pattern_t *sp_meshgradient_create_pattern(SPPaintServer *ps,
     return cp;
 }
 
-static cairo_pattern_t *
-sp_lineargradient_create_pattern(SPPaintServer *ps,
-                                 cairo_t */* ct */,
-                                 Geom::OptRect const &bbox,
-                                 double opacity)
-{
+static cairo_pattern_t *sp_meshgradient_create_pattern(SPPaintServer *ps, cairo_t * ct, Geom::OptRect const &bbox, double opacity) {
+	return ((SPMeshGradient*)ps)->cmeshgradient->onCreatePattern(ct, bbox, opacity);
+}
+
+cairo_pattern_t* CLinearGradient::onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity) {
+	SPLinearGradient* ps = this->splineargradient;
+
     SPLinearGradient *lg = SP_LINEARGRADIENT(ps);
     SPGradient *gr = SP_GRADIENT(ps);
 
@@ -2183,6 +2353,15 @@ sp_lineargradient_create_pattern(SPPaintServer *ps,
     return cp;
 }
 
+static cairo_pattern_t *
+sp_lineargradient_create_pattern(SPPaintServer *ps,
+                                 cairo_t *ct,
+                                 Geom::OptRect const &bbox,
+                                 double opacity)
+{
+	return ((SPLinearGradient*)ps)->clineargradient->onCreatePattern(ct, bbox, opacity);
+}
+
 cairo_pattern_t *
 sp_gradient_create_preview_pattern(SPGradient *gr, double width)
 {
diff --git a/src/sp-gradient.h b/src/sp-gradient.h
index 61b459eee..5c156f41c 100644
--- a/src/sp-gradient.h
+++ b/src/sp-gradient.h
@@ -87,6 +87,7 @@ std::vector<PaintTarget> const &allPaintTargets();
 
 } // namespace Inkscape
 
+class CGradient;
 
 /**
  * Gradient
@@ -95,6 +96,9 @@ std::vector<PaintTarget> const &allPaintTargets();
  * \todo fixme: Implement more here (Lauris)
  */
 class SPGradient : public SPPaintServer {
+public:
+	CGradient* cgradient;
+
 private:
     /** gradientUnits attribute */
     SPGradientUnits units;
@@ -197,7 +201,7 @@ private:
     void rebuildVector();
     void rebuildArray();
 
-    friend class SPGradientImpl;
+    friend class CGradient;
 //    friend class SPLGPainter;
 //    friend class SPRGPainter;
 };
@@ -210,6 +214,33 @@ struct SPGradientClass {
 };
 
 
+class CGradient : public CPaintServer {
+public:
+	CGradient(SPGradient* gradient);
+	virtual ~CGradient();
+
+    static void classInit(SPGradientClass *klass);
+    static void init(SPGradient *gr);
+
+    virtual void onBuild(SPDocument *document, Inkscape::XML::Node *repr);
+    virtual void onRelease();
+    virtual void onModified(guint flags);
+    virtual Inkscape::XML::Node* onWrite(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);
+
+    virtual void onChildAdded(Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
+    virtual void onRemoveChild(Inkscape::XML::Node *child);
+
+    virtual void onSet(unsigned key, gchar const *value);
+
+protected:
+    SPGradient* spgradient;
+};
+
+
 #include "sp-gradient-fns.h"
 
 #endif // SEEN_SP_GRADIENT_H
diff --git a/src/sp-linear-gradient.h b/src/sp-linear-gradient.h
index b99b6b293..9b766f474 100644
--- a/src/sp-linear-gradient.h
+++ b/src/sp-linear-gradient.h
@@ -9,8 +9,13 @@
 #include "svg/svg-length.h"
 #include "sp-linear-gradient-fns.h"
 
+class CLinearGradient;
+
 /** Linear gradient. */
-struct SPLinearGradient : public SPGradient {
+class SPLinearGradient : public SPGradient {
+public:
+	CLinearGradient* clineargradient;
+
     SVGLength x1;
     SVGLength y1;
     SVGLength x2;
@@ -22,6 +27,22 @@ struct SPLinearGradientClass {
     SPGradientClass parent_class;
 };
 
+
+class CLinearGradient : public CGradient {
+public:
+	CLinearGradient(SPLinearGradient* lineargradient);
+	virtual ~CLinearGradient();
+
+	virtual void onBuild(SPDocument *document, Inkscape::XML::Node *repr);
+	virtual void onSet(unsigned key, gchar const *value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+	virtual cairo_pattern_t* onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+	SPLinearGradient* splineargradient;
+};
+
+
 #endif /* !SP_LINEAR_GRADIENT_H */
 
 /*
diff --git a/src/sp-mesh-gradient.h b/src/sp-mesh-gradient.h
index 44d6c0e4c..a366165b4 100644
--- a/src/sp-mesh-gradient.h
+++ b/src/sp-mesh-gradient.h
@@ -9,8 +9,13 @@
 #include "sp-gradient.h"
 #include "sp-mesh-gradient-fns.h"
 
+class CMeshGradient;
+
 /** Mesh gradient. */
-struct SPMeshGradient : public SPGradient {
+class SPMeshGradient : public SPGradient {
+public:
+	CMeshGradient* cmeshgradient;
+
     SVGLength x;  // Upper left corner of mesh
     SVGLength y;  // Upper right corner of mesh
 };
@@ -21,6 +26,21 @@ struct SPMeshGradientClass {
 };
 
 
+class CMeshGradient : public CGradient {
+public:
+	CMeshGradient(SPMeshGradient* meshgradient);
+	virtual ~CMeshGradient();
+
+	virtual void onBuild(SPDocument *document, Inkscape::XML::Node *repr);
+	virtual void onSet(unsigned key, gchar const *value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+	virtual cairo_pattern_t* onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+	SPMeshGradient* spmeshgradient;
+};
+
+
 #endif /* !SP_MESH_GRADIENT_H */
 
 /*
diff --git a/src/sp-mesh-patch.h b/src/sp-mesh-patch.h
index b56a0b95f..2f5022234 100644
--- a/src/sp-mesh-patch.h
+++ b/src/sp-mesh-patch.h
@@ -30,8 +30,12 @@ struct SPMeshPatchClass;
 
 GType sp_meshpatch_get_type();
 
+class CMeshPatch;
+
 /** Gradient MeshPatch. */
-struct SPMeshPatch : public SPObject {
+class SPMeshPatch : public SPObject {
+public:
+	CMeshPatch* cmeshpatch;
 
     SPMeshPatch* getNextMeshPatch();
     SPMeshPatch* getPrevMeshPatch();
@@ -45,6 +49,21 @@ struct SPMeshPatchClass {
     SPObjectClass parent_class;
 };
 
+
+class CMeshPatch : public CObject {
+public:
+	CMeshPatch(SPMeshPatch* meshpatch);
+	virtual ~CMeshPatch();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onSet(unsigned int key, const gchar* value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+protected:
+	SPMeshPatch* spmeshpatch;
+};
+
+
 #endif /* !SEEN_SP_MESHPATCH_H */
 
 /*
diff --git a/src/sp-mesh-row.h b/src/sp-mesh-row.h
index 53e311bef..482e1270b 100644
--- a/src/sp-mesh-row.h
+++ b/src/sp-mesh-row.h
@@ -27,8 +27,12 @@ struct SPMeshRowClass;
 
 GType sp_meshrow_get_type();
 
+class CMeshRow;
+
 /** Gradient MeshRow. */
-struct SPMeshRow : public SPObject {
+class SPMeshRow : public SPObject {
+public:
+	CMeshRow* cmeshrow;
 
     SPMeshRow* getNextMeshRow();
     SPMeshRow* getPrevMeshRow();
@@ -39,6 +43,21 @@ struct SPMeshRowClass {
     SPObjectClass parent_class;
 };
 
+
+class CMeshRow : public CObject {
+public:
+	CMeshRow(SPMeshRow* meshrow);
+	virtual ~CMeshRow();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onSet(unsigned int key, const gchar* value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+protected:
+	SPMeshRow* spmeshrow;
+};
+
+
 #endif /* !SEEN_SP_MESHROW_H */
 
 /*
diff --git a/src/sp-paint-server.cpp b/src/sp-paint-server.cpp
index ae4a60ba6..6df8719df 100644
--- a/src/sp-paint-server.cpp
+++ b/src/sp-paint-server.cpp
@@ -64,11 +64,20 @@ static void sp_paint_server_class_init(SPPaintServerClass *psc)
     parent_class = static_cast<SPObjectClass *>(g_type_class_ref(SP_TYPE_OBJECT));
 }
 
-void SPPaintServer::init(SPPaintServer * /*ps*/)
+CPaintServer::CPaintServer(SPPaintServer* paintserver) : CObject(paintserver) {
+	this->sppaintserver = paintserver;
+}
+
+CPaintServer::~CPaintServer() {
+}
+
+void SPPaintServer::init(SPPaintServer * ps)
 {
+	ps->cpaintserver = new CPaintServer(ps);
+	ps->cobject = ps->cpaintserver;
 }
 
-cairo_pattern_t *sp_paint_server_create_pattern(SPPaintServer *ps,
+cairo_pattern_t *sp_paint_server_invoke_create_pattern(SPPaintServer *ps,
                                                 cairo_t *ct,
                                                 Geom::OptRect const &bbox,
                                                 double opacity)
@@ -77,14 +86,25 @@ cairo_pattern_t *sp_paint_server_create_pattern(SPPaintServer *ps,
     g_return_val_if_fail(SP_IS_PAINT_SERVER(ps), NULL);
 
     cairo_pattern_t *cp = NULL;
-    SPPaintServerClass *psc = (SPPaintServerClass *) G_OBJECT_GET_CLASS(ps);
-    if ( psc->pattern_new ) {
-        cp = (*psc->pattern_new)(ps, ct, bbox, opacity);
-    }
+
+    cp = ps->cpaintserver->onCreatePattern(ct, bbox, opacity);
 
     return cp;
 }
 
+// CPPIFY: make pure virtual
+cairo_pattern_t* CPaintServer::onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity) {
+	throw;
+}
+
+cairo_pattern_t *sp_paint_server_create_pattern(SPPaintServer *ps,
+                                                cairo_t *ct,
+                                                Geom::OptRect const &bbox,
+                                                double opacity)
+{
+	return sp_paint_server_invoke_create_pattern(ps, ct, bbox, opacity);
+}
+
 static cairo_pattern_t *
 sp_paint_server_create_dummy_pattern(SPPaintServer */*ps*/,
                                      cairo_t */* ct */,
diff --git a/src/sp-paint-server.h b/src/sp-paint-server.h
index a266ee5a5..ca5058b43 100644
--- a/src/sp-paint-server.h
+++ b/src/sp-paint-server.h
@@ -26,7 +26,12 @@
 #define SP_IS_PAINT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_PAINT_SERVER))
 #define SP_IS_PAINT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_PAINT_SERVER))
 
-struct SPPaintServer : public SPObject {
+class CPaintServer;
+
+class SPPaintServer : public SPObject {
+public:
+	CPaintServer* cpaintserver;
+
 protected:
     bool swatch;
 public:
@@ -46,6 +51,19 @@ struct SPPaintServerClass {
     cairo_pattern_t *(*pattern_new)(SPPaintServer *ps, cairo_t *ct, Geom::OptRect const &bbox, double opacity);
 };
 
+
+class CPaintServer : public CObject {
+public:
+	CPaintServer(SPPaintServer* paintserver);
+	virtual ~CPaintServer();
+
+	virtual cairo_pattern_t* onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+	SPPaintServer* sppaintserver;
+};
+
+
 cairo_pattern_t *sp_paint_server_create_pattern(SPPaintServer *ps, cairo_t *ct, Geom::OptRect const &bbox, double opacity);
 
 
diff --git a/src/sp-pattern.cpp b/src/sp-pattern.cpp
index 03afc1bf3..5e55cbe34 100644
--- a/src/sp-pattern.cpp
+++ b/src/sp-pattern.cpp
@@ -101,9 +101,20 @@ sp_pattern_class_init (SPPatternClass *klass)
     ps_class->pattern_new = sp_pattern_create_pattern;
 }
 
+CPattern::CPattern(SPPattern* pattern) : CPaintServer(pattern) {
+	this->sppattern = pattern;
+}
+
+CPattern::~CPattern() {
+}
+
 static void
 sp_pattern_init (SPPattern *pat)
 {
+	pat->cpattern = new CPattern(pat);
+	pat->cpaintserver = pat->cpattern;
+	pat->cobject = pat->cpattern;
+
 	pat->ref = new SPPatternReference(pat);
 	pat->ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(pattern_ref_changed), pat));
 
@@ -126,11 +137,10 @@ sp_pattern_init (SPPattern *pat)
 	new (&pat->modified_connection) sigc::connection();
 }
 
-static void
-sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
-	if (((SPObjectClass *) pattern_parent_class)->build)
-		(* ((SPObjectClass *) pattern_parent_class)->build) (object, document, repr);
+void CPattern::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) {
+	SPPattern* object = this->sppattern;
+
+	CPaintServer::onBuild(doc, repr);
 
 	object->readAttr( "patternUnits" );
 	object->readAttr( "patternContentUnits" );
@@ -143,11 +153,18 @@ sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *r
 	object->readAttr( "xlink:href" );
 
 	/* Register ourselves */
-	document->addResource("pattern", object);
+	doc->addResource("pattern", object);
 }
 
-static void sp_pattern_release(SPObject *object)
+static void
+sp_pattern_build (SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
+	((SPPattern*)object)->cpattern->onBuild(document, repr);
+}
+
+void CPattern::onRelease() {
+	SPPattern* object = this->sppattern;
+
     SPPattern *pat = reinterpret_cast<SPPattern *>(object);
 
     if (object->document) {
@@ -164,14 +181,17 @@ static void sp_pattern_release(SPObject *object)
 
     pat->modified_connection.~connection();
 
-    if (((SPObjectClass *) pattern_parent_class)->release) {
-        ((SPObjectClass *) pattern_parent_class)->release (object);
-    }
+    CPaintServer::onRelease();
 }
 
-static void
-sp_pattern_set (SPObject *object, unsigned int key, const gchar *value)
+static void sp_pattern_release(SPObject *object)
 {
+	((SPPattern*)object)->cpattern->onRelease();
+}
+
+void CPattern::onSet(unsigned int key, const gchar* value) {
+	SPPattern* object = this->sppattern;
+
 	SPPattern *pat = SP_PATTERN (object);
 
 	switch (key) {
@@ -280,12 +300,17 @@ sp_pattern_set (SPObject *object, unsigned int key, const gchar *value)
 		}
 		break;
 	default:
-		if (((SPObjectClass *) pattern_parent_class)->set)
-			((SPObjectClass *) pattern_parent_class)->set (object, key, value);
+		CPaintServer::onSet(key, value);
 		break;
 	}
 }
 
+static void
+sp_pattern_set (SPObject *object, unsigned int key, const gchar *value)
+{
+	((SPPattern*)object)->cpattern->onSet(key, value);
+}
+
 /* TODO: do we need a ::remove_child handler? */
 
 /* fixme: We need ::order_changed handler too (Lauris) */
@@ -306,9 +331,9 @@ GSList *pattern_getchildren(SPPattern *pat)
   return l;
 }
 
-static void
-sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags)
-{
+void CPattern::onUpdate(SPCtx* ctx, unsigned int flags) {
+	SPPattern* object = this->sppattern;
+
 	SPPattern *pat = SP_PATTERN (object);
 
 	if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
@@ -329,8 +354,14 @@ sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags)
 }
 
 static void
-sp_pattern_modified (SPObject *object, guint flags)
+sp_pattern_update (SPObject *object, SPCtx *ctx, unsigned int flags)
 {
+	((SPPattern*)object)->cpattern->onUpdate(ctx, flags);
+}
+
+void CPattern::onModified(unsigned int flags) {
+	SPPattern* object = this->sppattern;
+
 	SPPattern *pat = SP_PATTERN (object);
 
 	if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
@@ -350,6 +381,12 @@ sp_pattern_modified (SPObject *object, guint flags)
 	}
 }
 
+static void
+sp_pattern_modified (SPObject *object, guint flags)
+{
+	((SPPattern*)object)->cpattern->onModified(flags);
+}
+
 /**
 Gets called when the pattern is reattached to another <pattern>
 */
@@ -601,12 +638,9 @@ bool pattern_hasItemChildren (SPPattern *pat)
     return hasChildren;
 }
 
-static cairo_pattern_t *
-sp_pattern_create_pattern(SPPaintServer *ps,
-                          cairo_t *base_ct,
-                          Geom::OptRect const &bbox,
-                          double opacity)
-{
+cairo_pattern_t* CPattern::onCreatePattern(cairo_t *base_ct, Geom::OptRect const &bbox, double opacity) {
+	SPPattern* ps = this->sppattern;
+
     SPPattern *pat = SP_PATTERN (ps);
     Geom::Affine ps2user;
     Geom::Affine vb2ps = Geom::identity();
@@ -719,6 +753,15 @@ sp_pattern_create_pattern(SPPaintServer *ps,
     return cp;
 }
 
+static cairo_pattern_t *
+sp_pattern_create_pattern(SPPaintServer *ps,
+                          cairo_t *base_ct,
+                          Geom::OptRect const &bbox,
+                          double opacity)
+{
+	return ((SPPattern*)ps)->cpattern->onCreatePattern(base_ct, bbox, opacity);
+}
+
 /*
   Local Variables:
   mode:c++
diff --git a/src/sp-pattern.h b/src/sp-pattern.h
index debce86fb..329192c4b 100644
--- a/src/sp-pattern.h
+++ b/src/sp-pattern.h
@@ -53,7 +53,12 @@ enum {
     SP_PATTERN_UNITS_OBJECTBOUNDINGBOX
 };
 
-struct SPPattern : public SPPaintServer {
+class CPattern;
+
+class SPPattern : public SPPaintServer {
+public:
+	CPattern* cpattern;
+
     /* Reference (href) */
     gchar *href;
     SPPatternReference *ref;
@@ -82,6 +87,24 @@ struct SPPatternClass {
     SPPaintServerClass parent_class;
 };
 
+
+class CPattern : public CPaintServer {
+public:
+	CPattern(SPPattern* pattern);
+	virtual ~CPattern();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onRelease();
+	virtual void onSet(unsigned int key, const gchar* value);
+	virtual void onUpdate(SPCtx* ctx, unsigned int flags);
+	virtual void onModified(unsigned int flags);
+	virtual cairo_pattern_t* onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+	SPPattern* sppattern;
+};
+
+
 guint pattern_users (SPPattern *pattern);
 SPPattern *pattern_chain (SPPattern *pattern);
 SPPattern *sp_pattern_clone_if_necessary (SPItem *item, SPPattern *pattern, const gchar *property);
diff --git a/src/sp-radial-gradient.h b/src/sp-radial-gradient.h
index b46b9fff3..c2adc3f75 100644
--- a/src/sp-radial-gradient.h
+++ b/src/sp-radial-gradient.h
@@ -10,8 +10,13 @@
 #include "svg/svg-length.h"
 #include "sp-radial-gradient-fns.h"
 
+class CRadialGradient;
+
 /** Radial gradient. */
-struct SPRadialGradient : public SPGradient {
+class SPRadialGradient : public SPGradient {
+public:
+	CRadialGradient* cradialgradient;
+
     SVGLength cx;
     SVGLength cy;
     SVGLength r;
@@ -25,6 +30,21 @@ struct SPRadialGradientClass {
 };
 
 
+class CRadialGradient : public CGradient {
+public:
+	CRadialGradient(SPRadialGradient* radialgradient);
+	virtual ~CRadialGradient();
+
+	virtual void onBuild(SPDocument *document, Inkscape::XML::Node *repr);
+	virtual void onSet(unsigned key, gchar const *value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+	virtual cairo_pattern_t* onCreatePattern(cairo_t *ct, Geom::OptRect const &bbox, double opacity);
+
+protected:
+	SPRadialGradient* spradialgradient;
+};
+
+
 #endif /* !SP_RADIAL_GRADIENT_H */
 
 /*
diff --git a/src/sp-stop.h b/src/sp-stop.h
index c3b1e2753..79e0889df 100644
--- a/src/sp-stop.h
+++ b/src/sp-stop.h
@@ -27,8 +27,13 @@ struct SPStopClass;
 
 GType sp_stop_get_type();
 
+class CStop;
+
 /** Gradient stop. */
-struct SPStop : public SPObject {
+class SPStop : public SPObject {
+public:
+	CStop* cstop;
+
     /// \todo fixme: Should be SPSVGPercentage
     gfloat offset;
 
@@ -60,6 +65,21 @@ struct SPStopClass {
     SPObjectClass parent_class;
 };
 
+
+class CStop : public CObject {
+public:
+	CStop(SPStop* stop);
+	virtual ~CStop();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onSet(unsigned int key, const gchar* value);
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+protected:
+	SPStop* spstop;
+};
+
+
 guint32 sp_stop_get_rgba32(SPStop const *);