Added "virtual pads" to

  - SPFeFuncNode
  - SPFeDistantLight
  - SPFeMergeNode
  - SPFePointLight
  - SPFeSpotLight
  - SPFilter
  - SPFont
  - SPGuide

Changes in SPItem and SPNamedView.

(bzr r11608.1.49)

19 files changed, 1688 insertions, 148 deletions

diff --git a/src/filters/componenttransfer-funcnode.cpp b/src/filters/componenttransfer-funcnode.cpp
index 1a46ef01e..4299253f8 100644
--- a/src/filters/componenttransfer-funcnode.cpp
+++ b/src/filters/componenttransfer-funcnode.cpp
@@ -142,9 +142,19 @@ sp_fefuncnode_class_init(SPFeFuncNodeClass *klass)
     sp_object_class->update = sp_fefuncnode_update;
 }
 
+CFeFuncNode::CFeFuncNode(SPFeFuncNode* funcnode) : CObject(funcnode) {
+	this->spfefuncnode = funcnode;
+}
+
+CFeFuncNode::~CFeFuncNode() {
+}
+
 static void
 sp_fefuncnode_init(SPFeFuncNode *fefuncnode)
 {
+	fefuncnode->cfefuncnode = new CFeFuncNode(fefuncnode);
+	fefuncnode->cobject = fefuncnode->cfefuncnode;
+
     fefuncnode->type = Inkscape::Filters::COMPONENTTRANSFER_TYPE_IDENTITY;
     //fefuncnode->tableValues = NULL;
     fefuncnode->slope = 1;
@@ -159,13 +169,28 @@ sp_fefuncnode_init(SPFeFuncNode *fefuncnode)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_fefuncnode_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void
+//sp_fefuncnode_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) feFuncNode_parent_class)->build) {
 //        ((SPObjectClass *) feFuncNode_parent_class)->build(object, document, repr);
 //    }
-	// CPPIFY: todo
+//    //Read values of key attributes from XML nodes into object.
+//    object->readAttr( "type" );
+//    object->readAttr( "tableValues" );
+//    object->readAttr( "slope" );
+//    object->readAttr( "intercept" );
+//    object->readAttr( "amplitude" );
+//    object->readAttr( "exponent" );
+//    object->readAttr( "offset" );
+//
+//
+////is this necessary?
+//    document->addResource("fefuncnode", object); //maybe feFuncR, fefuncG, feFuncB and fefuncA ?
+//}
+
+void CFeFuncNode::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
 
     //Read values of key attributes from XML nodes into object.
     object->readAttr( "type" );
@@ -186,6 +211,19 @@ sp_fefuncnode_build(SPObject *object, SPDocument *document, Inkscape::XML::Node
  */
 static void sp_fefuncnode_release(SPObject *object)
 {
+//    //SPFeFuncNode *fefuncnode = SP_FEFUNCNODE(object);
+//
+//    if ( object->document ) {
+//        // Unregister ourselves
+//        object->document->removeResource("fefuncnode", object);
+//    }
+//
+////TODO: release resources here
+	((SPFeFuncNode*)object)->cfefuncnode->onRelease();
+}
+
+void CFeFuncNode::onRelease() {
+	SPFeFuncNode* object = this->spfefuncnode;
     //SPFeFuncNode *fefuncnode = SP_FEFUNCNODE(object);
 
     if ( object->document ) {
@@ -224,6 +262,69 @@ static Inkscape::Filters::FilterComponentTransferType sp_feComponenttransfer_rea
 static void
 sp_fefuncnode_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFeFuncNode *feFuncNode = SP_FEFUNCNODE(object);
+//    Inkscape::Filters::FilterComponentTransferType type;
+//    double read_num;
+//    switch(key) {
+//        case SP_ATTR_TYPE:
+//            type = sp_feComponenttransfer_read_type(value);
+//            if(type != feFuncNode->type) {
+//                feFuncNode->type = type;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_TABLEVALUES:
+//            if (value){
+//                feFuncNode->tableValues = helperfns_read_vector(value);
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_SLOPE:
+//            read_num = value ? helperfns_read_number(value) : 1;
+//            if (read_num != feFuncNode->slope) {
+//                feFuncNode->slope = read_num;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_INTERCEPT:
+//            read_num = value ? helperfns_read_number(value) : 0;
+//            if (read_num != feFuncNode->intercept) {
+//                feFuncNode->intercept = read_num;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_AMPLITUDE:
+//            read_num = value ? helperfns_read_number(value) : 1;
+//            if (read_num != feFuncNode->amplitude) {
+//                feFuncNode->amplitude = read_num;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_EXPONENT:
+//            read_num = value ? helperfns_read_number(value) : 1;
+//            if (read_num != feFuncNode->exponent) {
+//                feFuncNode->exponent = read_num;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        case SP_ATTR_OFFSET:
+//            read_num = value ? helperfns_read_number(value) : 0;
+//            if (read_num != feFuncNode->offset) {
+//                feFuncNode->offset = read_num;
+//                object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        default:
+//            if (((SPObjectClass *) feFuncNode_parent_class)->set)
+//                ((SPObjectClass *) feFuncNode_parent_class)->set(object, key, value);
+//            break;
+//    }
+	((SPFeFuncNode*)object)->cfefuncnode->onSet(key, value);
+}
+
+void CFeFuncNode::onSet(unsigned int key, gchar const *value) {
+	SPFeFuncNode* object = this->spfefuncnode;
+
     SPFeFuncNode *feFuncNode = SP_FEFUNCNODE(object);
     Inkscape::Filters::FilterComponentTransferType type;
     double read_num;
@@ -277,8 +378,9 @@ sp_fefuncnode_set(SPObject *object, unsigned int key, gchar const *value)
             }
             break;
         default:
-            if (((SPObjectClass *) feFuncNode_parent_class)->set)
-                ((SPObjectClass *) feFuncNode_parent_class)->set(object, key, value);
+//            if (((SPObjectClass *) feFuncNode_parent_class)->set)
+//                ((SPObjectClass *) feFuncNode_parent_class)->set(object, key, value);
+        	CObject::onSet(key, value);
             break;
     }
 }
@@ -289,6 +391,25 @@ sp_fefuncnode_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_fefuncnode_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    SPFeFuncNode *feFuncNode = SP_FEFUNCNODE(object);
+//    (void)feFuncNode;
+//
+//    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+//        /* do something to trigger redisplay, updates? */
+//        //TODO
+//        //object->readAttr( "azimuth" );
+//        //object->readAttr( "elevation" );
+//    }
+//
+//    if (((SPObjectClass *) feFuncNode_parent_class)->update) {
+//        ((SPObjectClass *) feFuncNode_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFeFuncNode*)object)->cfefuncnode->onUpdate(ctx, flags);
+}
+
+void CFeFuncNode::onUpdate(SPCtx *ctx, guint flags) {
+	SPFeFuncNode* object = this->spfefuncnode;
+
     SPFeFuncNode *feFuncNode = SP_FEFUNCNODE(object);
     (void)feFuncNode;
 
@@ -299,9 +420,10 @@ sp_fefuncnode_update(SPObject *object, SPCtx *ctx, guint flags)
         //object->readAttr( "elevation" );
     }
 
-    if (((SPObjectClass *) feFuncNode_parent_class)->update) {
-        ((SPObjectClass *) feFuncNode_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) feFuncNode_parent_class)->update) {
+//        ((SPObjectClass *) feFuncNode_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -310,6 +432,31 @@ sp_fefuncnode_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_fefuncnode_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFeFuncNode *fefuncnode = SP_FEFUNCNODE(object);
+//
+//    if (!repr) {
+//        repr = object->getRepr()->duplicate(doc);
+//    }
+//
+//    (void)fefuncnode;
+//    /*
+//TODO: I'm not sure what to do here...
+//
+//    if (fefuncnode->azimuth_set)
+//        sp_repr_set_css_double(repr, "azimuth", fefuncnode->azimuth);
+//    if (fefuncnode->elevation_set)
+//        sp_repr_set_css_double(repr, "elevation", fefuncnode->elevation);*/
+//
+//    if (((SPObjectClass *) feFuncNode_parent_class)->write) {
+//        ((SPObjectClass *) feFuncNode_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFeFuncNode*)object)->cfefuncnode->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFeFuncNode::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFeFuncNode* object = this->spfefuncnode;
     SPFeFuncNode *fefuncnode = SP_FEFUNCNODE(object);
 
     if (!repr) {
@@ -325,9 +472,10 @@ TODO: I'm not sure what to do here...
     if (fefuncnode->elevation_set)
         sp_repr_set_css_double(repr, "elevation", fefuncnode->elevation);*/
 
-    if (((SPObjectClass *) feFuncNode_parent_class)->write) {
-        ((SPObjectClass *) feFuncNode_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) feFuncNode_parent_class)->write) {
+//        ((SPObjectClass *) feFuncNode_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
diff --git a/src/filters/componenttransfer-funcnode.h b/src/filters/componenttransfer-funcnode.h
index d81e50577..55299b415 100644
--- a/src/filters/componenttransfer-funcnode.h
+++ b/src/filters/componenttransfer-funcnode.h
@@ -39,7 +39,12 @@
 class SPFeFuncNode;
 class SPFeFuncNodeClass;
 
-struct SPFeFuncNode : public SPObject {
+class CFeFuncNode;
+
+class SPFeFuncNode : public SPObject {
+public:
+	CFeFuncNode* cfefuncnode;
+
     Inkscape::Filters::FilterComponentTransferType type;
     std::vector<double> tableValues;
     double slope;
@@ -49,6 +54,24 @@ struct SPFeFuncNode : public SPObject {
     double offset;
 };
 
+class CFeFuncNode : public CObject {
+public:
+	CFeFuncNode(SPFeFuncNode* funcnode);
+	virtual ~CFeFuncNode();
+
+	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 Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFeFuncNode* spfefuncnode;
+};
+
 struct SPFeFuncNodeClass {
     SPObjectClass parent_class;
 };
diff --git a/src/filters/distantlight.cpp b/src/filters/distantlight.cpp
index 585afacf5..9255275d3 100644
--- a/src/filters/distantlight.cpp
+++ b/src/filters/distantlight.cpp
@@ -78,9 +78,19 @@ sp_fedistantlight_class_init(SPFeDistantLightClass *klass)
     sp_object_class->update = sp_fedistantlight_update;
 }
 
+CFeDistantLight::CFeDistantLight(SPFeDistantLight* distantlight) : CObject(distantlight) {
+	this->spfedistantlight = distantlight;
+}
+
+CFeDistantLight::~CFeDistantLight() {
+}
+
 static void
 sp_fedistantlight_init(SPFeDistantLight *fedistantlight)
 {
+	fedistantlight->cfedistantlight = new CFeDistantLight(fedistantlight);
+	fedistantlight->cobject = fedistantlight->cfedistantlight;
+
     fedistantlight->azimuth = 0;
     fedistantlight->elevation = 0;
     fedistantlight->azimuth_set = FALSE;
@@ -92,13 +102,24 @@ sp_fedistantlight_init(SPFeDistantLight *fedistantlight)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_fedistantlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void
+//sp_fedistantlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) feDistantLight_parent_class)->build) {
 //        ((SPObjectClass *) feDistantLight_parent_class)->build(object, document, repr);
 //    }
-	// CPPIFY: todo
+//    //Read values of key attributes from XML nodes into object.
+//    object->readAttr( "azimuth" );
+//    object->readAttr( "elevation" );
+//
+////is this necessary?
+//    document->addResource("fedistantlight", object);
+//}
+
+void CFeDistantLight::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
+
+	SPFeDistantLight* object = this->spfedistantlight;
 
     //Read values of key attributes from XML nodes into object.
     object->readAttr( "azimuth" );
@@ -114,6 +135,20 @@ sp_fedistantlight_build(SPObject *object, SPDocument *document, Inkscape::XML::N
 static void
 sp_fedistantlight_release(SPObject *object)
 {
+//    //SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
+//
+//    if ( object->document ) {
+//        // Unregister ourselves
+//        object->document->removeResource("fedistantlight", object);
+//    }
+//
+////TODO: release resources here
+	((SPFeDistantLight*)object)->cfedistantlight->onRelease();
+}
+
+void CFeDistantLight::onRelease() {
+	SPFeDistantLight* object = this->spfedistantlight;
+
     //SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
 
     if ( object->document ) {
@@ -130,6 +165,57 @@ sp_fedistantlight_release(SPObject *object)
 static void
 sp_fedistantlight_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
+//    gchar *end_ptr;
+//    switch (key) {
+//    case SP_ATTR_AZIMUTH:
+//        end_ptr =NULL;
+//        if (value) {
+//            fedistantlight->azimuth = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr) {
+//                fedistantlight->azimuth_set = TRUE;
+//            }
+//        }
+//        if (!value || !end_ptr) {
+//                fedistantlight->azimuth_set = FALSE;
+//                fedistantlight->azimuth = 0;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_ELEVATION:
+//        end_ptr =NULL;
+//        if (value) {
+//            fedistantlight->elevation = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr) {
+//                fedistantlight->elevation_set = TRUE;
+//            }
+//        }
+//        if (!value || !end_ptr) {
+//                fedistantlight->elevation_set = FALSE;
+//                fedistantlight->elevation = 0;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    default:
+//        // See if any parents need this value.
+//        if (((SPObjectClass *) feDistantLight_parent_class)->set) {
+//            ((SPObjectClass *) feDistantLight_parent_class)->set(object, key, value);
+//        }
+//        break;
+//    }
+	((SPFeDistantLight*)object)->cfedistantlight->onSet(key, value);
+}
+
+void CFeDistantLight::onSet(unsigned int key, gchar const *value) {
+	SPFeDistantLight* object = this->spfedistantlight;
     SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
     gchar *end_ptr;
     switch (key) {
@@ -171,9 +257,10 @@ sp_fedistantlight_set(SPObject *object, unsigned int key, gchar const *value)
         break;
     default:
         // See if any parents need this value.
-        if (((SPObjectClass *) feDistantLight_parent_class)->set) {
-            ((SPObjectClass *) feDistantLight_parent_class)->set(object, key, value);
-        }
+//        if (((SPObjectClass *) feDistantLight_parent_class)->set) {
+//            ((SPObjectClass *) feDistantLight_parent_class)->set(object, key, value);
+//        }
+    	CObject::onSet(key, value);
         break;
     }
 }
@@ -184,6 +271,23 @@ sp_fedistantlight_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_fedistantlight_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    SPFeDistantLight *feDistantLight = SP_FEDISTANTLIGHT(object);
+//    (void)feDistantLight;
+//
+//    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+//        /* do something to trigger redisplay, updates? */
+//        object->readAttr( "azimuth" );
+//        object->readAttr( "elevation" );
+//    }
+//
+//    if (((SPObjectClass *) feDistantLight_parent_class)->update) {
+//        ((SPObjectClass *) feDistantLight_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFeDistantLight*)object)->cfedistantlight->onUpdate(ctx, flags);
+}
+
+void CFeDistantLight::onUpdate(SPCtx *ctx, guint flags) {
+	SPFeDistantLight* object = this->spfedistantlight;
     SPFeDistantLight *feDistantLight = SP_FEDISTANTLIGHT(object);
     (void)feDistantLight;
 
@@ -193,9 +297,10 @@ sp_fedistantlight_update(SPObject *object, SPCtx *ctx, guint flags)
         object->readAttr( "elevation" );
     }
 
-    if (((SPObjectClass *) feDistantLight_parent_class)->update) {
-        ((SPObjectClass *) feDistantLight_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) feDistantLight_parent_class)->update) {
+//        ((SPObjectClass *) feDistantLight_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -204,6 +309,27 @@ sp_fedistantlight_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_fedistantlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
+//
+//    if (!repr) {
+//        repr = object->getRepr()->duplicate(doc);
+//    }
+//
+//    if (fedistantlight->azimuth_set)
+//        sp_repr_set_css_double(repr, "azimuth", fedistantlight->azimuth);
+//    if (fedistantlight->elevation_set)
+//        sp_repr_set_css_double(repr, "elevation", fedistantlight->elevation);
+//
+//    if (((SPObjectClass *) feDistantLight_parent_class)->write) {
+//        ((SPObjectClass *) feDistantLight_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFeDistantLight*)object)->cfedistantlight->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFeDistantLight::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFeDistantLight* object = this->spfedistantlight;
     SPFeDistantLight *fedistantlight = SP_FEDISTANTLIGHT(object);
 
     if (!repr) {
@@ -215,9 +341,10 @@ sp_fedistantlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape
     if (fedistantlight->elevation_set)
         sp_repr_set_css_double(repr, "elevation", fedistantlight->elevation);
 
-    if (((SPObjectClass *) feDistantLight_parent_class)->write) {
-        ((SPObjectClass *) feDistantLight_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) feDistantLight_parent_class)->write) {
+//        ((SPObjectClass *) feDistantLight_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
diff --git a/src/filters/distantlight.h b/src/filters/distantlight.h
index a68746334..de60cd507 100644
--- a/src/filters/distantlight.h
+++ b/src/filters/distantlight.h
@@ -29,7 +29,11 @@
 class SPFeDistantLight;
 class SPFeDistantLightClass;
 
-struct SPFeDistantLight : public SPObject {
+class CFeDistantLight;
+
+class SPFeDistantLight : public SPObject {
+public:
+	CFeDistantLight* cfedistantlight;
 
     /** azimuth attribute */
     gfloat azimuth;
@@ -39,6 +43,24 @@ struct SPFeDistantLight : public SPObject {
     guint elevation_set : 1;
 };
 
+class CFeDistantLight : public CObject {
+public:
+	CFeDistantLight(SPFeDistantLight* distantlight);
+	virtual ~CFeDistantLight();
+
+	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 Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFeDistantLight* spfedistantlight;
+};
+
 struct SPFeDistantLightClass {
     SPObjectClass parent_class;
 };
diff --git a/src/filters/mergenode.cpp b/src/filters/mergenode.cpp
index 1f57218c2..f5077b735 100644
--- a/src/filters/mergenode.cpp
+++ b/src/filters/mergenode.cpp
@@ -70,9 +70,19 @@ sp_feMergeNode_class_init(SPFeMergeNodeClass *klass)
     sp_object_class->update = sp_feMergeNode_update;
 }
 
+CFeMergeNode::CFeMergeNode(SPFeMergeNode* mergenode) : CObject(mergenode) {
+	this->spfemergenode = mergenode;
+}
+
+CFeMergeNode::~CFeMergeNode() {
+}
+
 static void
 sp_feMergeNode_init(SPFeMergeNode *feMergeNode)
 {
+	feMergeNode->cfemergenode = new CFeMergeNode(feMergeNode);
+	feMergeNode->cobject = feMergeNode->cfemergenode;
+
     feMergeNode->input = Inkscape::Filters::NR_FILTER_SLOT_NOT_SET;
 }
 
@@ -81,10 +91,15 @@ sp_feMergeNode_init(SPFeMergeNode *feMergeNode)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_feMergeNode_build(SPObject *object, SPDocument */*document*/, Inkscape::XML::Node */*repr*/)
-{
-    object->readAttr( "in" );
+//static void
+//sp_feMergeNode_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
+//    object->readAttr( "in" );
+//}
+
+void CFeMergeNode::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPFeMergeNode* object = this->spfemergenode;
+	object->readAttr( "in" );
 }
 
 /**
@@ -93,10 +108,15 @@ sp_feMergeNode_build(SPObject *object, SPDocument */*document*/, Inkscape::XML::
 static void
 sp_feMergeNode_release(SPObject *object)
 {
-    /* deal with our children and our selves here */
+//    /* deal with our children and our selves here */
+//
+//    if (((SPObjectClass *) feMergeNode_parent_class)->release)
+//        ((SPObjectClass *) feMergeNode_parent_class)->release(object);
+	((SPFeMergeNode*)object)->cfemergenode->onRelease();
+}
 
-    if (((SPObjectClass *) feMergeNode_parent_class)->release)
-        ((SPObjectClass *) feMergeNode_parent_class)->release(object);
+void CFeMergeNode::onRelease() {
+	CObject::onRelease();
 }
 
 /**
@@ -105,6 +125,26 @@ sp_feMergeNode_release(SPObject *object)
 static void
 sp_feMergeNode_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
+//    SPFeMerge *parent = SP_FEMERGE(object->parent);
+//
+//    if (key == SP_ATTR_IN) {
+//        int input = sp_filter_primitive_read_in(parent, value);
+//        if (input != feMergeNode->input) {
+//            feMergeNode->input = input;
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//    }
+//
+//    /* See if any parents need this value. */
+//    if (((SPObjectClass *) feMergeNode_parent_class)->set) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->set(object, key, value);
+//    }
+	((SPFeMergeNode*)object)->cfemergenode->onSet(key, value);
+}
+
+void CFeMergeNode::onSet(unsigned int key, gchar const *value) {
+	SPFeMergeNode* object = this->spfemergenode;
     SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
     SPFeMerge *parent = SP_FEMERGE(object->parent);
 
@@ -117,9 +157,10 @@ sp_feMergeNode_set(SPObject *object, unsigned int key, gchar const *value)
     }
 
     /* See if any parents need this value. */
-    if (((SPObjectClass *) feMergeNode_parent_class)->set) {
-        ((SPObjectClass *) feMergeNode_parent_class)->set(object, key, value);
-    }
+//    if (((SPObjectClass *) feMergeNode_parent_class)->set) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->set(object, key, value);
+//    }
+    CObject::onSet(key, value);
 }
 
 /**
@@ -128,15 +169,30 @@ sp_feMergeNode_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_feMergeNode_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    //SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
+//
+//    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+//        object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//    }
+//
+//    if (((SPObjectClass *) feMergeNode_parent_class)->update) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFeMergeNode*)object)->cfemergenode->onUpdate(ctx, flags);
+}
+
+void CFeMergeNode::onUpdate(SPCtx *ctx, guint flags) {
+	SPFeMergeNode* object = this->spfemergenode;
     //SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
 
     if (flags & SP_OBJECT_MODIFIED_FLAG) {
         object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
     }
 
-    if (((SPObjectClass *) feMergeNode_parent_class)->update) {
-        ((SPObjectClass *) feMergeNode_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) feMergeNode_parent_class)->update) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -145,6 +201,28 @@ sp_feMergeNode_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_feMergeNode_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    //SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
+//
+//    // Inkscape-only object, not copied during an "plain SVG" dump:
+//    if (flags & SP_OBJECT_WRITE_EXT) {
+//        if (repr) {
+//            // is this sane?
+//            //repr->mergeFrom(object->getRepr(), "id");
+//        } else {
+//            repr = object->getRepr()->duplicate(doc);
+//        }
+//    }
+//
+//    if (((SPObjectClass *) feMergeNode_parent_class)->write) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFeMergeNode*)object)->cfemergenode->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFeMergeNode::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFeMergeNode* object = this->spfemergenode;
     //SPFeMergeNode *feMergeNode = SP_FEMERGENODE(object);
 
     // Inkscape-only object, not copied during an "plain SVG" dump:
@@ -157,9 +235,10 @@ sp_feMergeNode_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::X
         }
     }
 
-    if (((SPObjectClass *) feMergeNode_parent_class)->write) {
-        ((SPObjectClass *) feMergeNode_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) feMergeNode_parent_class)->write) {
+//        ((SPObjectClass *) feMergeNode_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
diff --git a/src/filters/mergenode.h b/src/filters/mergenode.h
index 8352632a6..11ef03a93 100644
--- a/src/filters/mergenode.h
+++ b/src/filters/mergenode.h
@@ -24,10 +24,33 @@
 class SPFeMergeNode;
 class SPFeMergeNodeClass;
 
-struct SPFeMergeNode : public SPObject {
+class CFeMergeNode;
+
+class SPFeMergeNode : public SPObject {
+public:
+	CFeMergeNode* cfemergenode;
+
     int input;
 };
 
+class CFeMergeNode : public CObject {
+public:
+	CFeMergeNode(SPFeMergeNode* mergenode);
+	virtual ~CFeMergeNode();
+
+	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 Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFeMergeNode* spfemergenode;
+};
+
 struct SPFeMergeNodeClass {
     SPObjectClass parent_class;
 };
diff --git a/src/filters/pointlight.cpp b/src/filters/pointlight.cpp
index df513b393..74ee41301 100644
--- a/src/filters/pointlight.cpp
+++ b/src/filters/pointlight.cpp
@@ -78,9 +78,19 @@ sp_fepointlight_class_init(SPFePointLightClass *klass)
     sp_object_class->update = sp_fepointlight_update;
 }
 
+CFePointLight::CFePointLight(SPFePointLight* pointlight) : CObject(pointlight) {
+	this->spfepointlight = pointlight;
+}
+
+CFePointLight::~CFePointLight() {
+}
+
 static void
 sp_fepointlight_init(SPFePointLight *fepointlight)
 {
+	fepointlight->cfepointlight = new CFePointLight(fepointlight);
+	fepointlight->cobject = fepointlight->cfepointlight;
+
     fepointlight->x = 0;
     fepointlight->y = 0;
     fepointlight->z = 0;
@@ -95,13 +105,26 @@ sp_fepointlight_init(SPFePointLight *fepointlight)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_fepointlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void
+//sp_fepointlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) fePointLight_parent_class)->build) {
 //        ((SPObjectClass *) fePointLight_parent_class)->build(object, document, repr);
 //    }
-	// CPPIFY: todo
+//    //Read values of key attributes from XML nodes into object.
+//    object->readAttr( "x" );
+//    object->readAttr( "y" );
+//    object->readAttr( "z" );
+//
+////is this necessary?
+//    document->addResource("fepointlight", object);
+//	((SPFePointLight*)object)->cfepointlight->onBuild(document, repr);
+//}
+
+void CFePointLight::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
+
+	SPFePointLight* object = this->spfepointlight;
 
     //Read values of key attributes from XML nodes into object.
     object->readAttr( "x" );
@@ -118,6 +141,19 @@ sp_fepointlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Nod
 static void
 sp_fepointlight_release(SPObject *object)
 {
+//    //SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
+//
+//    if ( object->document ) {
+//        // Unregister ourselves
+//        object->document->removeResource("fepointlight", object);
+//    }
+//
+////TODO: release resources here
+	((SPFePointLight*)object)->cfepointlight->onRelease();
+}
+
+void CFePointLight::onRelease() {
+	SPFePointLight* object = this->spfepointlight;
     //SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
 
     if ( object->document ) {
@@ -134,6 +170,76 @@ sp_fepointlight_release(SPObject *object)
 static void
 sp_fepointlight_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
+//    gchar *end_ptr;
+//    switch (key) {
+//    case SP_ATTR_X:
+//        end_ptr = NULL;
+//        if (value) {
+//            fepointlight->x = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr) {
+//                fepointlight->x_set = TRUE;
+//            }
+//        }
+//        if (!value || !end_ptr) {
+//            fepointlight->x = 0;
+//            fepointlight->x_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_Y:
+//        end_ptr = NULL;
+//        if (value) {
+//            fepointlight->y = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr) {
+//                fepointlight->y_set = TRUE;
+//            }
+//        }
+//        if (!value || !end_ptr) {
+//            fepointlight->y = 0;
+//            fepointlight->y_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_Z:
+//        end_ptr = NULL;
+//        if (value) {
+//            fepointlight->z = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr) {
+//                fepointlight->z_set = TRUE;
+//            }
+//        }
+//        if (!value || !end_ptr) {
+//            fepointlight->z = 0;
+//            fepointlight->z_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    default:
+//        // See if any parents need this value.
+//        if (((SPObjectClass *) fePointLight_parent_class)->set) {
+//            ((SPObjectClass *) fePointLight_parent_class)->set(object, key, value);
+//        }
+//        break;
+//    }
+	((SPFePointLight*)object)->cfepointlight->onSet(key, value);
+}
+
+void CFePointLight::onSet(unsigned int key, gchar const *value) {
+	SPFePointLight* object = this->spfepointlight;
+
     SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
     gchar *end_ptr;
     switch (key) {
@@ -193,9 +299,10 @@ sp_fepointlight_set(SPObject *object, unsigned int key, gchar const *value)
         break;
     default:
         // See if any parents need this value.
-        if (((SPObjectClass *) fePointLight_parent_class)->set) {
-            ((SPObjectClass *) fePointLight_parent_class)->set(object, key, value);
-        }
+//        if (((SPObjectClass *) fePointLight_parent_class)->set) {
+//            ((SPObjectClass *) fePointLight_parent_class)->set(object, key, value);
+//        }
+    	CObject::onSet(key, value);
         break;
     }
 }
@@ -206,6 +313,25 @@ sp_fepointlight_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_fepointlight_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    SPFePointLight *fePointLight = SP_FEPOINTLIGHT(object);
+//    (void)fePointLight;
+//
+//    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+//        /* do something to trigger redisplay, updates? */
+//        object->readAttr( "x" );
+//        object->readAttr( "y" );
+//        object->readAttr( "z" );
+//    }
+//
+//    if (((SPObjectClass *) fePointLight_parent_class)->update) {
+//        ((SPObjectClass *) fePointLight_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFePointLight*)object)->cfepointlight->onUpdate(ctx, flags);
+}
+
+void CFePointLight::onUpdate(SPCtx *ctx, guint flags) {
+	SPFePointLight* object = this->spfepointlight;
+
     SPFePointLight *fePointLight = SP_FEPOINTLIGHT(object);
     (void)fePointLight;
 
@@ -216,9 +342,10 @@ sp_fepointlight_update(SPObject *object, SPCtx *ctx, guint flags)
         object->readAttr( "z" );
     }
 
-    if (((SPObjectClass *) fePointLight_parent_class)->update) {
-        ((SPObjectClass *) fePointLight_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) fePointLight_parent_class)->update) {
+//        ((SPObjectClass *) fePointLight_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -227,6 +354,29 @@ sp_fepointlight_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_fepointlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
+//
+//    if (!repr) {
+//        repr = object->getRepr()->duplicate(doc);
+//    }
+//
+//    if (fepointlight->x_set)
+//        sp_repr_set_css_double(repr, "x", fepointlight->x);
+//    if (fepointlight->y_set)
+//        sp_repr_set_css_double(repr, "y", fepointlight->y);
+//    if (fepointlight->z_set)
+//        sp_repr_set_css_double(repr, "z", fepointlight->z);
+//
+//    if (((SPObjectClass *) fePointLight_parent_class)->write) {
+//        ((SPObjectClass *) fePointLight_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFePointLight*)object)->cfepointlight->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFePointLight::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFePointLight* object = this->spfepointlight;
     SPFePointLight *fepointlight = SP_FEPOINTLIGHT(object);
 
     if (!repr) {
@@ -240,9 +390,10 @@ sp_fepointlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::
     if (fepointlight->z_set)
         sp_repr_set_css_double(repr, "z", fepointlight->z);
 
-    if (((SPObjectClass *) fePointLight_parent_class)->write) {
-        ((SPObjectClass *) fePointLight_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) fePointLight_parent_class)->write) {
+//        ((SPObjectClass *) fePointLight_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
diff --git a/src/filters/pointlight.h b/src/filters/pointlight.h
index c0b272021..0617c2333 100644
--- a/src/filters/pointlight.h
+++ b/src/filters/pointlight.h
@@ -29,7 +29,11 @@
 class SPFePointLight;
 class SPFePointLightClass;
 
-struct SPFePointLight : public SPObject {
+class CFePointLight;
+
+class SPFePointLight : public SPObject {
+public:
+	CFePointLight* cfepointlight;
 
     /** x coordinate of the light source */
     gfloat x; 
@@ -44,6 +48,24 @@ struct SPFePointLight : public SPObject {
     //other fields
 };
 
+class CFePointLight : public CObject {
+public:
+	CFePointLight(SPFePointLight* pointlight);
+	virtual ~CFePointLight();
+
+	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 Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFePointLight* spfepointlight;
+};
+
 struct SPFePointLightClass {
     SPObjectClass parent_class;
 };
diff --git a/src/filters/spotlight.cpp b/src/filters/spotlight.cpp
index 7ea4a0e7b..49cec8267 100644
--- a/src/filters/spotlight.cpp
+++ b/src/filters/spotlight.cpp
@@ -78,9 +78,19 @@ sp_fespotlight_class_init(SPFeSpotLightClass *klass)
     sp_object_class->update = sp_fespotlight_update;
 }
 
+CFeSpotLight::CFeSpotLight(SPFeSpotLight* spotlight) : CObject(spotlight) {
+	this->spfespotlight = spotlight;
+}
+
+CFeSpotLight::~CFeSpotLight() {
+}
+
 static void
 sp_fespotlight_init(SPFeSpotLight *fespotlight)
 {
+	fespotlight->cfespotlight = new CFeSpotLight(fespotlight);
+	fespotlight->cobject = fespotlight->cfespotlight;
+
     fespotlight->x = 0;
     fespotlight->y = 0;
     fespotlight->z = 0;
@@ -105,13 +115,31 @@ sp_fespotlight_init(SPFeSpotLight *fespotlight)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_fespotlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void
+//sp_fespotlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) feSpotLight_parent_class)->build) {
 //        ((SPObjectClass *) feSpotLight_parent_class)->build(object, document, repr);
 //    }
-	// CPPIFY: todo
+//    //Read values of key attributes from XML nodes into object.
+//    object->readAttr( "x" );
+//    object->readAttr( "y" );
+//    object->readAttr( "z" );
+//    object->readAttr( "pointsAtX" );
+//    object->readAttr( "pointsAtY" );
+//    object->readAttr( "pointsAtZ" );
+//    object->readAttr( "specularExponent" );
+//    object->readAttr( "limitingConeAngle" );
+//
+////is this necessary?
+//    document->addResource("fespotlight", object);
+//	((SPFeSpotLight*)object)->cfespotlight->onBuild(document, repr);
+//}
+
+void CFeSpotLight::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
+
+	SPFeSpotLight* object = this->spfespotlight;
 
     //Read values of key attributes from XML nodes into object.
     object->readAttr( "x" );
@@ -133,6 +161,19 @@ sp_fespotlight_build(SPObject *object, SPDocument *document, Inkscape::XML::Node
 static void
 sp_fespotlight_release(SPObject *object)
 {
+//    //SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
+//
+//    if ( object->document ) {
+//        // Unregister ourselves
+//        object->document->removeResource("fespotlight", object);
+//    }
+//
+////TODO: release resources here
+	((SPFeSpotLight*)object)->cfespotlight->onRelease();
+}
+
+void CFeSpotLight::onRelease() {
+	SPFeSpotLight* object = this->spfespotlight;
     //SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
 
     if ( object->document ) {
@@ -149,6 +190,159 @@ sp_fespotlight_release(SPObject *object)
 static void
 sp_fespotlight_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
+//    gchar *end_ptr;
+//
+//    switch (key) {
+//    case SP_ATTR_X:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->x = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->x_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->x = 0;
+//            fespotlight->x_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_Y:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->y = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->y_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->y = 0;
+//            fespotlight->y_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_Z:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->z = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->z_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->z = 0;
+//            fespotlight->z_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_POINTSATX:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->pointsAtX = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->pointsAtX_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->pointsAtX = 0;
+//            fespotlight->pointsAtX_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_POINTSATY:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->pointsAtY = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->pointsAtY_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->pointsAtY = 0;
+//            fespotlight->pointsAtY_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_POINTSATZ:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->pointsAtZ = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->pointsAtZ_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->pointsAtZ = 0;
+//            fespotlight->pointsAtZ_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_SPECULAREXPONENT:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->specularExponent = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->specularExponent_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->specularExponent = 1;
+//            fespotlight->specularExponent_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    case SP_ATTR_LIMITINGCONEANGLE:
+//        end_ptr = NULL;
+//        if (value) {
+//            fespotlight->limitingConeAngle = g_ascii_strtod(value, &end_ptr);
+//            if (end_ptr)
+//                fespotlight->limitingConeAngle_set = TRUE;
+//        }
+//        if(!value || !end_ptr) {
+//            fespotlight->limitingConeAngle = 90;
+//            fespotlight->limitingConeAngle_set = FALSE;
+//        }
+//        if (object->parent &&
+//                (SP_IS_FEDIFFUSELIGHTING(object->parent) ||
+//                 SP_IS_FESPECULARLIGHTING(object->parent))) {
+//            object->parent->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//        }
+//        break;
+//    default:
+//        // See if any parents need this value.
+//        if (((SPObjectClass *) feSpotLight_parent_class)->set) {
+//            ((SPObjectClass *) feSpotLight_parent_class)->set(object, key, value);
+//        }
+//        break;
+//    }
+	((SPFeSpotLight*)object)->cfespotlight->onSet(key, value);
+}
+
+void CFeSpotLight::onSet(unsigned int key, gchar const *value) {
+	SPFeSpotLight* object = this->spfespotlight;
+
     SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
     gchar *end_ptr;
 
@@ -291,9 +485,10 @@ sp_fespotlight_set(SPObject *object, unsigned int key, gchar const *value)
         break;
     default:
         // See if any parents need this value.
-        if (((SPObjectClass *) feSpotLight_parent_class)->set) {
-            ((SPObjectClass *) feSpotLight_parent_class)->set(object, key, value);
-        }
+//        if (((SPObjectClass *) feSpotLight_parent_class)->set) {
+//            ((SPObjectClass *) feSpotLight_parent_class)->set(object, key, value);
+//        }
+    	CObject::onSet(key, value);
         break;
     }
 }
@@ -304,6 +499,30 @@ sp_fespotlight_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_fespotlight_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    SPFeSpotLight *feSpotLight = SP_FESPOTLIGHT(object);
+//    (void)feSpotLight;
+//
+//    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+//        /* do something to trigger redisplay, updates? */
+//        object->readAttr( "x" );
+//        object->readAttr( "y" );
+//        object->readAttr( "z" );
+//        object->readAttr( "pointsAtX" );
+//        object->readAttr( "pointsAtY" );
+//        object->readAttr( "pointsAtZ" );
+//        object->readAttr( "specularExponent" );
+//        object->readAttr( "limitingConeAngle" );
+//    }
+//
+//    if (((SPObjectClass *) feSpotLight_parent_class)->update) {
+//        ((SPObjectClass *) feSpotLight_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFeSpotLight*)object)->cfespotlight->onUpdate(ctx, flags);
+}
+
+void CFeSpotLight::onUpdate(SPCtx *ctx, guint flags) {
+	SPFeSpotLight* object = this->spfespotlight;
+
     SPFeSpotLight *feSpotLight = SP_FESPOTLIGHT(object);
     (void)feSpotLight;
 
@@ -319,9 +538,10 @@ sp_fespotlight_update(SPObject *object, SPCtx *ctx, guint flags)
         object->readAttr( "limitingConeAngle" );
     }
 
-    if (((SPObjectClass *) feSpotLight_parent_class)->update) {
-        ((SPObjectClass *) feSpotLight_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) feSpotLight_parent_class)->update) {
+//        ((SPObjectClass *) feSpotLight_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -330,6 +550,39 @@ sp_fespotlight_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_fespotlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
+//
+//    if (!repr) {
+//        repr = object->getRepr()->duplicate(doc);
+//    }
+//
+//    if (fespotlight->x_set)
+//        sp_repr_set_css_double(repr, "x", fespotlight->x);
+//    if (fespotlight->y_set)
+//        sp_repr_set_css_double(repr, "y", fespotlight->y);
+//    if (fespotlight->z_set)
+//        sp_repr_set_css_double(repr, "z", fespotlight->z);
+//    if (fespotlight->pointsAtX_set)
+//        sp_repr_set_css_double(repr, "pointsAtX", fespotlight->pointsAtX);
+//    if (fespotlight->pointsAtY_set)
+//        sp_repr_set_css_double(repr, "pointsAtY", fespotlight->pointsAtY);
+//    if (fespotlight->pointsAtZ_set)
+//        sp_repr_set_css_double(repr, "pointsAtZ", fespotlight->pointsAtZ);
+//    if (fespotlight->specularExponent_set)
+//        sp_repr_set_css_double(repr, "specularExponent", fespotlight->specularExponent);
+//    if (fespotlight->limitingConeAngle_set)
+//        sp_repr_set_css_double(repr, "limitingConeAngle", fespotlight->limitingConeAngle);
+//
+//    if (((SPObjectClass *) feSpotLight_parent_class)->write) {
+//        ((SPObjectClass *) feSpotLight_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFeSpotLight*)object)->cfespotlight->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFeSpotLight::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFeSpotLight* object = this->spfespotlight;
     SPFeSpotLight *fespotlight = SP_FESPOTLIGHT(object);
 
     if (!repr) {
@@ -353,9 +606,10 @@ sp_fespotlight_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::X
     if (fespotlight->limitingConeAngle_set)
         sp_repr_set_css_double(repr, "limitingConeAngle", fespotlight->limitingConeAngle);
 
-    if (((SPObjectClass *) feSpotLight_parent_class)->write) {
-        ((SPObjectClass *) feSpotLight_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) feSpotLight_parent_class)->write) {
+//        ((SPObjectClass *) feSpotLight_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
diff --git a/src/filters/spotlight.h b/src/filters/spotlight.h
index 6e2463c08..9cc5bd958 100644
--- a/src/filters/spotlight.h
+++ b/src/filters/spotlight.h
@@ -29,7 +29,11 @@
 class SPFeSpotLight;
 class SPFeSpotLightClass;
 
-struct SPFeSpotLight : public SPObject {
+class CFeSpotLight;
+
+class SPFeSpotLight : public SPObject {
+public:
+	CFeSpotLight* cfespotlight;
 
     /** x coordinate of the light source */
     gfloat x; 
@@ -58,6 +62,24 @@ struct SPFeSpotLight : public SPObject {
     //other fields
 };
 
+class CFeSpotLight : public CObject {
+public:
+	CFeSpotLight(SPFeSpotLight* spotlight);
+	virtual ~CFeSpotLight();
+
+	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 Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFeSpotLight* spfespotlight;
+};
+
 struct SPFeSpotLightClass {
     SPObjectClass parent_class;
 };
diff --git a/src/sp-filter.cpp b/src/sp-filter.cpp
index 85a898958..2a2c6de1c 100644
--- a/src/sp-filter.cpp
+++ b/src/sp-filter.cpp
@@ -95,9 +95,19 @@ sp_filter_class_init(SPFilterClass *klass)
     sp_object_class->remove_child = sp_filter_remove_child;
 }
 
+CFilter::CFilter(SPFilter* filter) : CObject(filter) {
+	this->spfilter = filter;
+}
+
+CFilter::~CFilter() {
+}
+
 static void
 sp_filter_init(SPFilter *filter)
 {
+	filter->cfilter = new CFilter(filter);
+	filter->cobject = filter->cfilter;
+
     filter->href = new SPFilterReference(filter);
     filter->href->changedSignal().connect(sigc::bind(sigc::ptr_fun(filter_ref_changed), filter));
 
@@ -127,13 +137,28 @@ sp_filter_init(SPFilter *filter)
  * our name must be associated with a repr via "sp_object_type_register".  Best done through
  * sp-object-repr.cpp's repr_name_entries array.
  */
-static void
-sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void
+//sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) filter_parent_class)->build) {
 //        ((SPObjectClass *) filter_parent_class)->build(object, document, repr);
 //    }
-	// CPPIFY: todo
+//    //Read values of key attributes from XML nodes into object.
+//    object->readAttr( "filterUnits" );
+//    object->readAttr( "primitiveUnits" );
+//    object->readAttr( "x" );
+//    object->readAttr( "y" );
+//    object->readAttr( "width" );
+//    object->readAttr( "height" );
+//    object->readAttr( "filterRes" );
+//    object->readAttr( "xlink:href" );
+//
+////is this necessary?
+//    document->addResource("filter", object);
+//}
+
+void CFilter::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPFilter* object = this->spfilter;
 
     //Read values of key attributes from XML nodes into object.
     object->readAttr( "filterUnits" );
@@ -154,6 +179,33 @@ sp_filter_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *rep
  */
 static void sp_filter_release(SPObject *object)
 {
+//    SPFilter *filter = SP_FILTER(object);
+//
+//    if (object->document) {
+//        // Unregister ourselves
+//        object->document->removeResource("filter", object);
+//    }
+//
+////TODO: release resources here
+//
+//    //release href
+//    if (filter->href) {
+//        filter->modified_connection.disconnect();
+//        filter->href->detach();
+//        delete filter->href;
+//        filter->href = NULL;
+//    }
+//
+//    filter->modified_connection.~connection();
+//    delete filter->_image_name;
+//
+//    if (((SPObjectClass *) filter_parent_class)->release)
+//        ((SPObjectClass *) filter_parent_class)->release(object);
+	((SPFilter*)object)->cfilter->onRelease();
+}
+
+void CFilter::onRelease() {
+	SPFilter* object = this->spfilter;
     SPFilter *filter = SP_FILTER(object);
 
     if (object->document) {
@@ -174,8 +226,9 @@ static void sp_filter_release(SPObject *object)
     filter->modified_connection.~connection();
     delete filter->_image_name;
 
-    if (((SPObjectClass *) filter_parent_class)->release)
-        ((SPObjectClass *) filter_parent_class)->release(object);
+//    if (((SPObjectClass *) filter_parent_class)->release)
+//        ((SPObjectClass *) filter_parent_class)->release(object);
+    CObject::onRelease();
 }
 
 /**
@@ -184,6 +237,81 @@ static void sp_filter_release(SPObject *object)
 static void
 sp_filter_set(SPObject *object, unsigned int key, gchar const *value)
 {
+//    SPFilter *filter = SP_FILTER(object);
+//
+//    switch (key) {
+//        case SP_ATTR_FILTERUNITS:
+//            if (value) {
+//                if (!strcmp(value, "userSpaceOnUse")) {
+//                    filter->filterUnits = SP_FILTER_UNITS_USERSPACEONUSE;
+//                } else {
+//                    filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
+//                }
+//                filter->filterUnits_set = TRUE;
+//            } else {
+//                filter->filterUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
+//                filter->filterUnits_set = FALSE;
+//            }
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_PRIMITIVEUNITS:
+//            if (value) {
+//                if (!strcmp(value, "objectBoundingBox")) {
+//                    filter->primitiveUnits = SP_FILTER_UNITS_OBJECTBOUNDINGBOX;
+//                } else {
+//                    filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
+//                }
+//                filter->primitiveUnits_set = TRUE;
+//            } else {
+//                filter->primitiveUnits = SP_FILTER_UNITS_USERSPACEONUSE;
+//                filter->primitiveUnits_set = FALSE;
+//            }
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_X:
+//            filter->x.readOrUnset(value);
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_Y:
+//            filter->y.readOrUnset(value);
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_WIDTH:
+//            filter->width.readOrUnset(value);
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_HEIGHT:
+//            filter->height.readOrUnset(value);
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_FILTERRES:
+//            filter->filterRes.set(value);
+//            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            break;
+//        case SP_ATTR_XLINK_HREF:
+//            if (value) {
+//                try {
+//                    filter->href->attach(Inkscape::URI(value));
+//                } catch (Inkscape::BadURIException &e) {
+//                    g_warning("%s", e.what());
+//                    filter->href->detach();
+//                }
+//            } else {
+//                filter->href->detach();
+//            }
+//            break;
+//        default:
+//            // See if any parents need this value.
+//            if (((SPObjectClass *) filter_parent_class)->set) {
+//                ((SPObjectClass *) filter_parent_class)->set(object, key, value);
+//            }
+//            break;
+//    }
+	((SPFilter*)object)->cfilter->onSet(key, value);
+}
+
+void CFilter::onSet(unsigned int key, gchar const *value) {
+	SPFilter* object = this->spfilter;
     SPFilter *filter = SP_FILTER(object);
 
     switch (key) {
@@ -249,9 +377,10 @@ sp_filter_set(SPObject *object, unsigned int key, gchar const *value)
             break;
         default:
             // See if any parents need this value.
-            if (((SPObjectClass *) filter_parent_class)->set) {
-                ((SPObjectClass *) filter_parent_class)->set(object, key, value);
-            }
+//            if (((SPObjectClass *) filter_parent_class)->set) {
+//                ((SPObjectClass *) filter_parent_class)->set(object, key, value);
+//            }
+        	CObject::onSet(key, value);
             break;
     }
 }
@@ -262,6 +391,22 @@ sp_filter_set(SPObject *object, unsigned int key, gchar const *value)
 static void
 sp_filter_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    //SPFilter *filter = SP_FILTER(object);
+//
+//    if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
+//                 SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
+//
+//        /* do something to trigger redisplay, updates? */
+//
+//    }
+//
+//    if (((SPObjectClass *) filter_parent_class)->update) {
+//        ((SPObjectClass *) filter_parent_class)->update(object, ctx, flags);
+//    }
+	((SPFilter*)object)->cfilter->onUpdate(ctx, flags);
+}
+
+void CFilter::onUpdate(SPCtx *ctx, guint flags) {
     //SPFilter *filter = SP_FILTER(object);
 
     if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG |
@@ -271,9 +416,10 @@ sp_filter_update(SPObject *object, SPCtx *ctx, guint flags)
 
     }
 
-    if (((SPObjectClass *) filter_parent_class)->update) {
-        ((SPObjectClass *) filter_parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) filter_parent_class)->update) {
+//        ((SPObjectClass *) filter_parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 /**
@@ -282,6 +428,120 @@ sp_filter_update(SPObject *object, SPCtx *ctx, guint flags)
 static Inkscape::XML::Node *
 sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFilter *filter = SP_FILTER(object);
+//
+//    // Original from sp-item-group.cpp
+//    if (flags & SP_OBJECT_WRITE_BUILD) {
+//        if (!repr) {
+//            repr = doc->createElement("svg:filter");
+//        }
+//        GSList *l = NULL;
+//        for ( SPObject *child = object->firstChild(); child; child = child->getNext() ) {
+//            Inkscape::XML::Node *crepr = child->updateRepr(doc, NULL, flags);
+//            if (crepr) {
+//                l = g_slist_prepend (l, crepr);
+//            }
+//        }
+//        while (l) {
+//            repr->addChild((Inkscape::XML::Node *) l->data, NULL);
+//            Inkscape::GC::release((Inkscape::XML::Node *) l->data);
+//            l = g_slist_remove (l, l->data);
+//        }
+//    } else {
+//        for ( SPObject *child = object->firstChild() ; child; child = child->getNext() ) {
+//            child->updateRepr(flags);
+//        }
+//    }
+//
+//    if ((flags & SP_OBJECT_WRITE_ALL) || filter->filterUnits_set) {
+//        switch (filter->filterUnits) {
+//            case SP_FILTER_UNITS_USERSPACEONUSE:
+//                repr->setAttribute("filterUnits", "userSpaceOnUse");
+//                break;
+//            default:
+//                repr->setAttribute("filterUnits", "objectBoundingBox");
+//                break;
+//        }
+//    }
+//
+//    if ((flags & SP_OBJECT_WRITE_ALL) || filter->primitiveUnits_set) {
+//        switch (filter->primitiveUnits) {
+//            case SP_FILTER_UNITS_OBJECTBOUNDINGBOX:
+//                repr->setAttribute("primitiveUnits", "objectBoundingBox");
+//                break;
+//            default:
+//                repr->setAttribute("primitiveUnits", "userSpaceOnUse");
+//                break;
+//        }
+//    }
+//
+//    if (filter->x._set) {
+//        sp_repr_set_svg_double(repr, "x", filter->x.computed);
+//    } else {
+//        repr->setAttribute("x", NULL);
+//    }
+//
+//    if (filter->y._set) {
+//        sp_repr_set_svg_double(repr, "y", filter->y.computed);
+//    } else {
+//        repr->setAttribute("y", NULL);
+//    }
+//
+//    if (filter->width._set) {
+//        sp_repr_set_svg_double(repr, "width", filter->width.computed);
+//    } else {
+//        repr->setAttribute("width", NULL);
+//    }
+//
+//    if (filter->height._set) {
+//        sp_repr_set_svg_double(repr, "height", filter->height.computed);
+//    } else {
+//        repr->setAttribute("height", NULL);
+//    }
+//
+//    if (filter->filterRes.getNumber()>=0) {
+//        gchar *tmp = filter->filterRes.getValueString();
+//        repr->setAttribute("filterRes", tmp);
+//        g_free(tmp);
+//    } else {
+//        repr->setAttribute("filterRes", NULL);
+//    }
+//
+//    if (filter->href->getURI()) {
+//        gchar *uri_string = filter->href->getURI()->toString();
+//        repr->setAttribute("xlink:href", uri_string);
+//        g_free(uri_string);
+//    }
+//
+//    // TODO: This is evil, correctly implement support for color-interpolation-filters!!!
+//    // The color-interpolation-filters attribute is initially set to linearRGB according to the SVG standard.
+//    // However, Inkscape completely ignores it and implicitly assumes that it is sRGB (like color-interpolation).
+//    // This results in a discrepancy between Inkscape and other renderers in how they render filters.
+//    // To mitigate this problem I've (Jasper van de Gronde,th.v.d.gronde@hccnet.nl) added this to ensure that at least
+//    // any filters written by Inkscape will henceforth be rendered the same in other renderers.
+//    // In the future Inkscape should have proper support for the color-interpolation properties and this should be changed.
+//
+//    // repr->setAttribute("color-interpolation-filters", "sRGB");
+//
+//    // Actually, the above line is not correct as the attribute is only allowed on filter
+//    // primitives and not <filter> objects. However, it is allowed as a property in a style
+//    // attribute. Note, this property must also be set in sp-filter-chemistry, filter_new() as the
+//    // code here is not necessarily called when a new filter is created.  29 Aug 2011 Tav.
+//    SPCSSAttr *css = sp_repr_css_attr_new();
+//    sp_repr_css_set_property(css, "color-interpolation-filters", "sRGB");
+//    sp_repr_css_change(repr, css, "style");
+//    sp_repr_css_attr_unref(css);
+//
+//    if (((SPObjectClass *) filter_parent_class)->write) {
+//        ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
+//    }
+//
+//    return repr;
+	return ((SPFilter*)object)->cfilter->onWrite(doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFilter::onWrite(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFilter* object = this->spfilter;
     SPFilter *filter = SP_FILTER(object);
 
     // Original from sp-item-group.cpp
@@ -386,9 +646,10 @@ sp_filter_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::N
     sp_repr_css_change(repr, css, "style");
     sp_repr_css_attr_unref(css);
 
-    if (((SPObjectClass *) filter_parent_class)->write) {
-        ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
-    }
+//    if (((SPObjectClass *) filter_parent_class)->write) {
+//        ((SPObjectClass *) filter_parent_class)->write(object, doc, repr, flags);
+//    }
+    CObject::onWrite(doc, repr, flags);
 
     return repr;
 }
@@ -424,10 +685,22 @@ static void filter_ref_modified(SPObject */*href*/, guint /*flags*/, SPFilter *f
 static void
 sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 {
+//    //SPFilter *f = SP_FILTER(object);
+//
+//    if (((SPObjectClass *) filter_parent_class)->child_added)
+//        (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
+//
+//    object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+	((SPFilter*)object)->cfilter->onChildAdded(child, ref);
+}
+
+void CFilter::onChildAdded(Inkscape::XML::Node *child, Inkscape::XML::Node *ref) {
+	SPFilter* object = this->spfilter;
     //SPFilter *f = SP_FILTER(object);
 
-    if (((SPObjectClass *) filter_parent_class)->child_added)
-        (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
+//    if (((SPObjectClass *) filter_parent_class)->child_added)
+//        (* ((SPObjectClass *) filter_parent_class)->child_added)(object, child, ref);
+	CObject::onChildAdded(child, ref);
 
     object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
@@ -438,12 +711,24 @@ sp_filter_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XM
 static void
 sp_filter_remove_child(SPObject *object, Inkscape::XML::Node *child)
 {
-//    SPFilter *f = SP_FILTER(object);
+////    SPFilter *f = SP_FILTER(object);
+//
+//    if (((SPObjectClass *) filter_parent_class)->remove_child)
+//        (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
+//
+//    object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+	((SPFilter*)object)->cfilter->onRemoveChild(child);
+}
 
-    if (((SPObjectClass *) filter_parent_class)->remove_child)
-        (* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
+void CFilter::onRemoveChild(Inkscape::XML::Node *child) {
+	SPFilter* object = this->spfilter;
+	//    SPFilter *f = SP_FILTER(object);
 
-    object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//	if (((SPObjectClass *) filter_parent_class)->remove_child)
+//		(* ((SPObjectClass *) filter_parent_class)->remove_child)(object, child);
+	CObject::onRemoveChild(child);
+
+	object->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
 
 void sp_filter_build_renderer(SPFilter *sp_filter, Inkscape::Filters::Filter *nr_filter)
diff --git a/src/sp-filter.h b/src/sp-filter.h
index d0529e542..7a90bfcc3 100644
--- a/src/sp-filter.h
+++ b/src/sp-filter.h
@@ -42,7 +42,12 @@ struct ltstr {
     bool operator()(const char* s1, const char* s2) const;
 };
 
-struct SPFilter : public SPObject {
+
+class CFilter;
+
+class SPFilter : public SPObject {
+public:
+	CFilter* cfilter;
 
     SPFilterUnits filterUnits;
     guint filterUnits_set : 1;
@@ -62,6 +67,27 @@ struct SPFilter : public SPObject {
     int _image_number_next;
 };
 
+class CFilter : public CObject {
+public:
+	CFilter(SPFilter* filter);
+	virtual ~CFilter();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onRelease();
+
+	virtual void onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref);
+	virtual void onRemoveChild(Inkscape::XML::Node* child);
+
+	virtual void onSet(unsigned int key, const gchar* value);
+
+	virtual void onUpdate(SPCtx* ctx, unsigned int flags);
+
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFilter* spfilter;
+};
+
 struct SPFilterClass {
     SPObjectClass parent_class;
 };
diff --git a/src/sp-font.cpp b/src/sp-font.cpp
index c91abdaba..ec7af0dd1 100644
--- a/src/sp-font.cpp
+++ b/src/sp-font.cpp
@@ -86,8 +86,18 @@ double FNT_DEFAULT_ADV = 90; // TODO determine proper default
 double FNT_DEFAULT_ASCENT = 90; // TODO determine proper default
 double FNT_UNITS_PER_EM = 90; // TODO determine proper default
 
+CFont::CFont(SPFont* font) : CObject(font) {
+	this->spfont = font;
+}
+
+CFont::~CFont() {
+}
+
 static void sp_font_init(SPFont *font)
 {
+	font->cfont = new CFont(font);
+	font->cobject = font->cfont;
+
     font->horiz_origin_x = 0;
     font->horiz_origin_y = 0;
     font->horiz_adv_x = FNT_DEFAULT_ADV;
@@ -96,25 +106,37 @@ static void sp_font_init(SPFont *font)
     font->vert_adv_y = FNT_UNITS_PER_EM;
 }
 
-static void sp_font_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void sp_font_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) (parent_class))->build) {
 //        ((SPObjectClass *) (parent_class))->build(object, document, repr);
 //    }
-	// CPPIFY: todo
-
-
-    object->readAttr( "horiz-origin-x" );
-    object->readAttr( "horiz-origin-y" );
-    object->readAttr( "horiz-adv-x" );
-    object->readAttr( "vert-origin-x" );
-    object->readAttr( "vert-origin-y" );
-    object->readAttr( "vert-adv-y" );
-
-    document->addResource("font", object);
+//
+//    object->readAttr( "horiz-origin-x" );
+//    object->readAttr( "horiz-origin-y" );
+//    object->readAttr( "horiz-adv-x" );
+//    object->readAttr( "vert-origin-x" );
+//    object->readAttr( "vert-origin-y" );
+//    object->readAttr( "vert-adv-y" );
+//
+//    document->addResource("font", object);
+//}
+
+void CFont::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
+
+	SPFont* object = this->spfont;
+
+	object->readAttr( "horiz-origin-x" );
+	object->readAttr( "horiz-origin-y" );
+	object->readAttr( "horiz-adv-x" );
+	object->readAttr( "vert-origin-x" );
+	object->readAttr( "vert-origin-y" );
+	object->readAttr( "vert-adv-y" );
+
+	document->addResource("font", object);
 }
 
-
 static void sp_font_children_modified(SPFont */*sp_font*/)
 {
 }
@@ -125,10 +147,23 @@ static void sp_font_children_modified(SPFont */*sp_font*/)
 static void
 sp_font_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 {
-    SPFont *f = SP_FONT(object);
+//    SPFont *f = SP_FONT(object);
+//
+//    if (((SPObjectClass *) parent_class)->child_added)
+//        (* ((SPObjectClass *) parent_class)->child_added)(object, child, ref);
+//
+//    sp_font_children_modified(f);
+//    object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+	((SPFont*)object)->cfont->onChildAdded(child, ref);
+}
 
-    if (((SPObjectClass *) parent_class)->child_added)
-        (* ((SPObjectClass *) parent_class)->child_added)(object, child, ref);
+void CFont::onChildAdded(Inkscape::XML::Node *child, Inkscape::XML::Node *ref) {
+	SPFont* object = this->spfont;
+    SPFont *f = SP_FONT(object);
+//
+//    if (((SPObjectClass *) parent_class)->child_added)
+//        (* ((SPObjectClass *) parent_class)->child_added)(object, child, ref);
+    CObject::onChildAdded(child, ref);
 
     sp_font_children_modified(f);
     object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
@@ -141,10 +176,23 @@ sp_font_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML:
 static void
 sp_font_remove_child(SPObject *object, Inkscape::XML::Node *child)
 {
+//    SPFont *f = SP_FONT(object);
+//
+//    if (((SPObjectClass *) parent_class)->remove_child)
+//        (* ((SPObjectClass *) parent_class)->remove_child)(object, child);
+//
+//    sp_font_children_modified(f);
+//    object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
+	((SPFont*)object)->cfont->onRemoveChild(child);
+}
+
+void CFont::onRemoveChild(Inkscape::XML::Node* child) {
+	SPFont* object = this->spfont;
     SPFont *f = SP_FONT(object);
 
-    if (((SPObjectClass *) parent_class)->remove_child)
-        (* ((SPObjectClass *) parent_class)->remove_child)(object, child);
+//    if (((SPObjectClass *) parent_class)->remove_child)
+//        (* ((SPObjectClass *) parent_class)->remove_child)(object, child);
+    CObject::onRemoveChild(child);
 
     sp_font_children_modified(f);
     object->parent->requestModified(SP_OBJECT_MODIFIED_FLAG);
@@ -152,16 +200,98 @@ sp_font_remove_child(SPObject *object, Inkscape::XML::Node *child)
 
 static void sp_font_release(SPObject *object)
 {
+//    //SPFont *font = SP_FONT(object);
+//    object->document->removeResource("font", object);
+//
+//    if (((SPObjectClass *) parent_class)->release) {
+//        ((SPObjectClass *) parent_class)->release(object);
+//    }
+	((SPFont*)object)->cfont->onRelease();
+}
+
+void CFont::onRelease() {
     //SPFont *font = SP_FONT(object);
+	SPFont* object = this->spfont;
+
     object->document->removeResource("font", object);
 
-    if (((SPObjectClass *) parent_class)->release) {
-        ((SPObjectClass *) parent_class)->release(object);
-    }
+//    if (((SPObjectClass *) parent_class)->release) {
+//        ((SPObjectClass *) parent_class)->release(object);
+//    }
+    CObject::onRelease();
 }
 
 static void sp_font_set(SPObject *object, unsigned int key, const gchar *value)
 {
+//    SPFont *font = SP_FONT(object);
+//
+//    // TODO these are floating point, so some epsilon comparison would be good
+//    switch (key) {
+//        case SP_ATTR_HORIZ_ORIGIN_X:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : 0;
+//            if (number != font->horiz_origin_x){
+//                font->horiz_origin_x = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        case SP_ATTR_HORIZ_ORIGIN_Y:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : 0;
+//            if (number != font->horiz_origin_y){
+//                font->horiz_origin_y = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        case SP_ATTR_HORIZ_ADV_X:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : FNT_DEFAULT_ADV;
+//            if (number != font->horiz_adv_x){
+//                font->horiz_adv_x = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        case SP_ATTR_VERT_ORIGIN_X:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : FNT_DEFAULT_ADV / 2.0;
+//            if (number != font->vert_origin_x){
+//                font->vert_origin_x = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        case SP_ATTR_VERT_ORIGIN_Y:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : FNT_DEFAULT_ASCENT;
+//            if (number != font->vert_origin_y){
+//                font->vert_origin_y = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        case SP_ATTR_VERT_ADV_Y:
+//        {
+//            double number = value ? g_ascii_strtod(value, 0) : FNT_UNITS_PER_EM;
+//            if (number != font->vert_adv_y){
+//                font->vert_adv_y = number;
+//                object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+//            }
+//            break;
+//        }
+//        default:
+//            if (((SPObjectClass *) (parent_class))->set) {
+//                ((SPObjectClass *) (parent_class))->set(object, key, value);
+//            }
+//            break;
+//    }
+	((SPFont*)object)->cfont->onSet(key, value);
+}
+
+void CFont::onSet(unsigned int key, const gchar *value) {
+	SPFont* object = this->spfont;
     SPFont *font = SP_FONT(object);
 
     // TODO these are floating point, so some epsilon comparison would be good
@@ -221,9 +351,10 @@ static void sp_font_set(SPObject *object, unsigned int key, const gchar *value)
             break;
         }
         default:
-            if (((SPObjectClass *) (parent_class))->set) {
-                ((SPObjectClass *) (parent_class))->set(object, key, value);
-            }
+//            if (((SPObjectClass *) (parent_class))->set) {
+//                ((SPObjectClass *) (parent_class))->set(object, key, value);
+//            }
+        	CObject::onSet(key, value);
             break;
     }
 }
@@ -234,6 +365,24 @@ static void sp_font_set(SPObject *object, unsigned int key, const gchar *value)
 static void
 sp_font_update(SPObject *object, SPCtx *ctx, guint flags)
 {
+//    if (flags & (SP_OBJECT_MODIFIED_FLAG)) {
+//        object->readAttr( "horiz-origin-x" );
+//        object->readAttr( "horiz-origin-y" );
+//        object->readAttr( "horiz-adv-x" );
+//        object->readAttr( "vert-origin-x" );
+//        object->readAttr( "vert-origin-y" );
+//        object->readAttr( "vert-adv-y" );
+//    }
+//
+//    if (((SPObjectClass *) parent_class)->update) {
+//        ((SPObjectClass *) parent_class)->update(object, ctx, flags);
+//    }
+	((SPFont*)object)->cfont->onUpdate(ctx, flags);
+}
+
+void CFont::onUpdate(SPCtx *ctx, guint flags) {
+	SPFont* object = this->spfont;
+
     if (flags & (SP_OBJECT_MODIFIED_FLAG)) {
         object->readAttr( "horiz-origin-x" );
         object->readAttr( "horiz-origin-y" );
@@ -243,15 +392,51 @@ sp_font_update(SPObject *object, SPCtx *ctx, guint flags)
         object->readAttr( "vert-adv-y" );
     }
 
-    if (((SPObjectClass *) parent_class)->update) {
-        ((SPObjectClass *) parent_class)->update(object, ctx, flags);
-    }
+//    if (((SPObjectClass *) parent_class)->update) {
+//        ((SPObjectClass *) parent_class)->update(object, ctx, flags);
+//    }
+    CObject::onUpdate(ctx, flags);
 }
 
 #define COPY_ATTR(rd,rs,key) (rd)->setAttribute((key), rs->attribute(key));
 
 static Inkscape::XML::Node *sp_font_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
+//    SPFont *font = SP_FONT(object);
+//
+//    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
+//        repr = xml_doc->createElement("svg:font");
+//    }
+//
+//    sp_repr_set_svg_double(repr, "horiz-origin-x", font->horiz_origin_x);
+//    sp_repr_set_svg_double(repr, "horiz-origin-y", font->horiz_origin_y);
+//    sp_repr_set_svg_double(repr, "horiz-adv-x", font->horiz_adv_x);
+//    sp_repr_set_svg_double(repr, "vert-origin-x", font->vert_origin_x);
+//    sp_repr_set_svg_double(repr, "vert-origin-y", font->vert_origin_y);
+//    sp_repr_set_svg_double(repr, "vert-adv-y", font->vert_adv_y);
+//
+//    if (repr != object->getRepr()) {
+//        // All the below COPY_ATTR funtions are directly using
+//        //  the XML Tree while they shouldn't
+//        COPY_ATTR(repr, object->getRepr(), "horiz-origin-x");
+//        COPY_ATTR(repr, object->getRepr(), "horiz-origin-y");
+//        COPY_ATTR(repr, object->getRepr(), "horiz-adv-x");
+//        COPY_ATTR(repr, object->getRepr(), "vert-origin-x");
+//        COPY_ATTR(repr, object->getRepr(), "vert-origin-y");
+//        COPY_ATTR(repr, object->getRepr(), "vert-adv-y");
+//    }
+//
+//    if (((SPObjectClass *) (parent_class))->write) {
+//        ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags);
+//    }
+//
+//    return repr;
+
+	return ((SPFont*)object)->cfont->onWrite(xml_doc, repr, flags);
+}
+
+Inkscape::XML::Node* CFont::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	SPFont* object = this->spfont;
     SPFont *font = SP_FONT(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
@@ -276,12 +461,14 @@ static Inkscape::XML::Node *sp_font_write(SPObject *object, Inkscape::XML::Docum
         COPY_ATTR(repr, object->getRepr(), "vert-adv-y");
     }
 
-    if (((SPObjectClass *) (parent_class))->write) {
-        ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags);
-    }
+//    if (((SPObjectClass *) (parent_class))->write) {
+//        ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags);
+//    }
+    CObject::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
+
 #endif //#ifdef ENABLE_SVG_FONTS
 /*
   Local Variables:
diff --git a/src/sp-font.h b/src/sp-font.h
index a0f895a52..786fb7f97 100644
--- a/src/sp-font.h
+++ b/src/sp-font.h
@@ -24,7 +24,12 @@
 #define SP_IS_FONT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_FONT))
 #define SP_IS_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_FONT))
 
-struct SPFont : public SPObject {
+class CFont;
+
+class SPFont : public SPObject {
+public:
+	CFont* cfont;
+
     double horiz_origin_x;
     double horiz_origin_y;
     double horiz_adv_x;
@@ -33,6 +38,27 @@ struct SPFont : public SPObject {
     double vert_adv_y;
 };
 
+class CFont : public CObject {
+public:
+	CFont(SPFont* font);
+	virtual ~CFont();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onRelease();
+
+	virtual void onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref);
+	virtual void onRemoveChild(Inkscape::XML::Node* child);
+
+	virtual void onSet(unsigned int key, const gchar* value);
+
+	virtual void onUpdate(SPCtx* ctx, unsigned int flags);
+
+	virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document* doc, Inkscape::XML::Node* repr, guint flags);
+
+private:
+	SPFont* spfont;
+};
+
 struct SPFontClass {
     SPObjectClass parent_class;
 };
diff --git a/src/sp-guide.cpp b/src/sp-guide.cpp
index 9fc0a4c7d..081a667a3 100644
--- a/src/sp-guide.cpp
+++ b/src/sp-guide.cpp
@@ -116,8 +116,18 @@ static void sp_guide_class_init(SPGuideClass *gc)
                                                       (GParamFlags) G_PARAM_READWRITE));
 }
 
+CGuide::CGuide(SPGuide* guide) : CObject(guide) {
+	this->spguide = guide;
+}
+
+CGuide::~CGuide() {
+}
+
 static void sp_guide_init(SPGuide *guide)
 {
+	guide->cguide = new CGuide(guide);
+	guide->cobject = guide->cguide;
+
     guide->normal_to_line = Geom::Point(0.,1.);
     guide->point_on_line = Geom::Point(0.,0.);
     guide->color = 0x0000ff7f;
@@ -156,12 +166,25 @@ static void sp_guide_get_property(GObject *object, guint prop_id, GValue *value,
     }
 }
 
-static void sp_guide_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+//static void sp_guide_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
 //    if (((SPObjectClass *) (parent_class))->build) {
 //        (* ((SPObjectClass *) (parent_class))->build)(object, document, repr);
 //    }
-	// CPPIFY: todo
+//
+//    object->readAttr( "inkscape:label" );
+//    object->readAttr( "orientation" );
+//    object->readAttr( "position" );
+//
+//    /* Register */
+//    document->addResource("guide", object);
+//	((SPGuide*)object)->cguide->onBuild(document, repr);
+//}
+
+void CGuide::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	CObject::onBuild(document, repr);
+
+	SPGuide* object = this->spguide;
 
     object->readAttr( "inkscape:label" );
     object->readAttr( "orientation" );
@@ -173,6 +196,26 @@ static void sp_guide_build(SPObject *object, SPDocument *document, Inkscape::XML
 
 static void sp_guide_release(SPObject *object)
 {
+//    SPGuide *guide = (SPGuide *) object;
+//
+//    while (guide->views) {
+//        sp_guideline_delete(SP_GUIDELINE(guide->views->data));
+//        guide->views = g_slist_remove(guide->views, guide->views->data);
+//    }
+//
+//    if (object->document) {
+//        // Unregister ourselves
+//        object->document->removeResource("guide", object);
+//    }
+//
+//    if (((SPObjectClass *) parent_class)->release) {
+//        ((SPObjectClass *) parent_class)->release(object);
+//    }
+	((SPGuide*)object)->cguide->onRelease();
+}
+
+void CGuide::onRelease() {
+	SPGuide* object = this->spguide;
     SPGuide *guide = (SPGuide *) object;
 
     while (guide->views) {
@@ -185,13 +228,93 @@ static void sp_guide_release(SPObject *object)
         object->document->removeResource("guide", object);
     }
 
-    if (((SPObjectClass *) parent_class)->release) {
-        ((SPObjectClass *) parent_class)->release(object);
-    }
+//    if (((SPObjectClass *) parent_class)->release) {
+//        ((SPObjectClass *) parent_class)->release(object);
+//    }
+    CObject::onRelease();
 }
 
 static void sp_guide_set(SPObject *object, unsigned int key, const gchar *value)
 {
+//    SPGuide *guide = SP_GUIDE(object);
+//
+//    switch (key) {
+//    case SP_ATTR_INKSCAPE_LABEL:
+//        if (value) {
+//            guide->label = g_strdup(value);
+//        } else {
+//            guide->label = NULL;
+//        }
+//
+//        sp_guide_set_label(*guide, guide->label, false);
+//        break;
+//    case SP_ATTR_ORIENTATION:
+//        {
+//            if (value && !strcmp(value, "horizontal")) {
+//                /* Visual representation of a horizontal line, constrain vertically (y coordinate). */
+//                guide->normal_to_line = Geom::Point(0., 1.);
+//            } else if (value && !strcmp(value, "vertical")) {
+//                guide->normal_to_line = Geom::Point(1., 0.);
+//            } else if (value) {
+//                gchar ** strarray = g_strsplit(value, ",", 2);
+//                double newx, newy;
+//                unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+//                success += sp_svg_number_read_d(strarray[1], &newy);
+//                g_strfreev (strarray);
+//                if (success == 2 && (fabs(newx) > 1e-6 || fabs(newy) > 1e-6)) {
+//                    Geom::Point direction(newx, newy);
+//                    direction.normalize();
+//                    guide->normal_to_line = direction;
+//                } else {
+//                    // default to vertical line for bad arguments
+//                    guide->normal_to_line = Geom::Point(1., 0.);
+//                }
+//            } else {
+//                // default to vertical line for bad arguments
+//                guide->normal_to_line = Geom::Point(1., 0.);
+//            }
+//            sp_guide_set_normal(*guide, guide->normal_to_line, false);
+//        }
+//        break;
+//    case SP_ATTR_POSITION:
+//        {
+//            if (value) {
+//                gchar ** strarray = g_strsplit(value, ",", 2);
+//                double newx, newy;
+//                unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+//                success += sp_svg_number_read_d(strarray[1], &newy);
+//                g_strfreev (strarray);
+//                if (success == 2) {
+//                    guide->point_on_line = Geom::Point(newx, newy);
+//                } else if (success == 1) {
+//                    // before 0.46 style guideline definition.
+//                    const gchar *attr = object->getRepr()->attribute("orientation");
+//                    if (attr && !strcmp(attr, "horizontal")) {
+//                        guide->point_on_line = Geom::Point(0, newx);
+//                    } else {
+//                        guide->point_on_line = Geom::Point(newx, 0);
+//                    }
+//                }
+//            } else {
+//                // default to (0,0) for bad arguments
+//                guide->point_on_line = Geom::Point(0,0);
+//            }
+//            // update position in non-committing way
+//            // fixme: perhaps we need to add an update method instead, and request_update here
+//            sp_guide_moveto(*guide, guide->point_on_line, false);
+//        }
+//        break;
+//    default:
+//            if (((SPObjectClass *) (parent_class))->set) {
+//                ((SPObjectClass *) (parent_class))->set(object, key, value);
+//            }
+//            break;
+//    }
+	((SPGuide*)object)->cguide->onSet(key, value);
+}
+
+void CGuide::onSet(unsigned int key, const gchar *value) {
+	SPGuide* object = this->spguide;
     SPGuide *guide = SP_GUIDE(object);
 
     switch (key) {
@@ -261,9 +384,10 @@ static void sp_guide_set(SPObject *object, unsigned int key, const gchar *value)
         }
         break;
     default:
-            if (((SPObjectClass *) (parent_class))->set) {
-                ((SPObjectClass *) (parent_class))->set(object, key, value);
-            }
+//            if (((SPObjectClass *) (parent_class))->set) {
+//                ((SPObjectClass *) (parent_class))->set(object, key, value);
+//            }
+    	CObject::onSet(key, value);
             break;
     }
 }
diff --git a/src/sp-guide.h b/src/sp-guide.h
index 319e12305..ff350528b 100644
--- a/src/sp-guide.h
+++ b/src/sp-guide.h
@@ -28,9 +28,14 @@ struct SPCanvasGroup;
 #define SP_IS_GUIDE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), SP_TYPE_GUIDE))
 #define SP_IS_GUIDE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), SP_TYPE_GUIDE))
 
+
+class CGuide;
+
 /* Represents the constraint on p that dot(g.direction, p) == g.position. */
 class SPGuide : public SPObject {
 public:
+	CGuide* cguide;
+
     char* label;
     Geom::Point normal_to_line;
     Geom::Point point_on_line;
@@ -51,6 +56,20 @@ public:
     double getDistanceFrom(Geom::Point const &pt) const;
 };
 
+class CGuide : public CObject {
+public:
+	CGuide(SPGuide* guide);
+	virtual ~CGuide();
+
+	virtual void onBuild(SPDocument* doc, Inkscape::XML::Node* repr);
+	virtual void onRelease();
+	virtual void onSet(unsigned int key, const gchar* value);
+
+private:
+	SPGuide* spguide;
+};
+
+
 class SPGuideClass {
 public:
     SPObjectClass parent_class;
diff --git a/src/sp-item.cpp b/src/sp-item.cpp
index ebbe04f03..1ba1aa7ea 100644
--- a/src/sp-item.cpp
+++ b/src/sp-item.cpp
@@ -442,10 +442,10 @@ void CItem::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
 }
 
 // CPPIFY: remove
-void SPItem::sp_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
-    ((SPItem*)object)->citem->onBuild(document, repr);
-}
+//void SPItem::sp_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+//{
+//    ((SPItem*)object)->citem->onBuild(document, repr);
+//}
 
 void CItem::onRelease() {
 	SPItem* item = this->spitem;
@@ -766,7 +766,8 @@ Inkscape::XML::Node *SPItem::sp_item_write(SPObject *const object, Inkscape::XML
 
 // CPPIFY: make pure virtual
 Geom::OptRect CItem::onBbox(Geom::Affine const &transform, SPItem::BBoxType type) {
-	throw;
+	//throw;
+	return Geom::OptRect();
 }
 
 /**
@@ -942,7 +943,7 @@ unsigned SPItem::pos_in_parent()
 
 // CPPIFY: make pure virtual, see below!
 void CItem::onSnappoints(std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs) {
-	throw;
+	//throw;
 }
 
 // CPPIFY: remove
@@ -995,7 +996,7 @@ void SPItem::getSnappoints(std::vector<Inkscape::SnapCandidatePoint> &p, Inkscap
 
 // CPPIFY: make pure virtual
 void CItem::onPrint(SPPrintContext* ctx) {
-	throw;
+	//throw;
 }
 
 void SPItem::invoke_print(SPPrintContext *ctx)
@@ -1086,7 +1087,8 @@ unsigned SPItem::display_key_new(unsigned numkeys)
 
 // CPPIFY: make pure virtual
 Inkscape::DrawingItem* CItem::onShow(Inkscape::Drawing &drawing, unsigned int key, unsigned int flags) {
-	throw;
+	//throw;
+	return 0;
 }
 
 Inkscape::DrawingItem *SPItem::invoke_show(Inkscape::Drawing &drawing, unsigned key, unsigned flags)
@@ -1144,7 +1146,7 @@ Inkscape::DrawingItem *SPItem::invoke_show(Inkscape::Drawing &drawing, unsigned
 
 // CPPIFY: make pure virtual
 void CItem::onHide(unsigned int key) {
-	throw;
+	//throw;
 }
 
 void SPItem::invoke_hide(unsigned key)
diff --git a/src/sp-item.h b/src/sp-item.h
index d28769b2c..446602143 100644
--- a/src/sp-item.h
+++ b/src/sp-item.h
@@ -232,7 +232,7 @@ private:
 
     static void sp_item_init(SPItem *item);
 
-    static void sp_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
+    //static void sp_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
     static void sp_item_release(SPObject *object);
     static void sp_item_set(SPObject *object, unsigned key, gchar const *value);
     static void sp_item_update(SPObject *object, SPCtx *ctx, guint flags);
diff --git a/src/sp-namedview.cpp b/src/sp-namedview.cpp
index 2e36bd082..0300c7140 100644
--- a/src/sp-namedview.cpp
+++ b/src/sp-namedview.cpp
@@ -318,9 +318,9 @@ void CNamedView::onRelease() {
         namedview->grids = g_slist_remove_link(namedview->grids, namedview->grids); // deletes first entry
     }
 
-    if (((SPObjectClass *) parent_class)->release) {
-        ((SPObjectClass *) parent_class)->release(object);
-    }
+//    if (((SPObjectClass *) parent_class)->release) {
+//        ((SPObjectClass *) parent_class)->release(object);
+//    }
     CObjectGroup::onRelease();
 
     namedview->snap_manager.~SnapManager();