Registered classes with new factory. Hkern, Vkern and FeFuncX have to be rewritten, as they aren't real classes.

(bzr r11608.1.69)

63 files changed, 766 insertions, 76 deletions

diff --git a/src/box3d-side.cpp b/src/box3d-side.cpp
index 3b46b203a..23bc269d5 100644
--- a/src/box3d-side.cpp
+++ b/src/box3d-side.cpp
@@ -28,6 +28,16 @@ struct SPPathClass;
 
 static void box3d_side_compute_corner_ids(Box3DSide *side, unsigned int corners[4]);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createBox3DSide() {
+		return new Box3DSide();
+	}
+
+	bool box3DSideRegistered = SPFactory::instance().registerObject("inkscape:box3dside", createBox3DSide);
+}
+
 G_DEFINE_TYPE(Box3DSide, box3d_side, G_TYPE_OBJECT);
 
 static void box3d_side_class_init(Box3DSideClass *klass)
diff --git a/src/box3d.cpp b/src/box3d.cpp
index 8f7c20c49..c3f6a1dbb 100644
--- a/src/box3d.cpp
+++ b/src/box3d.cpp
@@ -43,6 +43,16 @@ static void box3d_ref_changed(SPObject *old_ref, SPObject *ref, SPBox3D *box);
 
 static gint counter = 0;
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createBox3D() {
+		return new SPBox3D();
+	}
+
+	bool box3DRegistered = SPFactory::instance().registerObject("inkscape:box3d", createBox3D);
+}
+
 G_DEFINE_TYPE(SPBox3D, box3d, G_TYPE_OBJECT);
 
 static void box3d_class_init(SPBox3DClass *klass)
diff --git a/src/color-profile.cpp b/src/color-profile.cpp
index 63cb3addc..f1d89111d 100644
--- a/src/color-profile.cpp
+++ b/src/color-profile.cpp
@@ -184,6 +184,18 @@ cmsHPROFILE ColorProfileImpl::getNULLProfile() {
 
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
+
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createColorProfile() {
+		return new Inkscape::ColorProfile();
+	}
+
+	bool rectRegistered = SPFactory::instance().registerObject("svg:color-profile", createColorProfile);
+}
+
+
 /**
  * Register ColorProfile class and return its type.
  */
diff --git a/src/filters/blend.cpp b/src/filters/blend.cpp
index e5159d522..4ca8a8496 100644
--- a/src/filters/blend.cpp
+++ b/src/filters/blend.cpp
@@ -30,6 +30,16 @@
 #include "display/nr-filter-blend.h"
 #include "display/nr-filter-types.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createBlend() {
+		return new SPFeBlend();
+	}
+
+	bool blendRegistered = SPFactory::instance().registerObject("svg:feBlend", createBlend);
+}
+
 /* FeBlend base class */
 G_DEFINE_TYPE(SPFeBlend, sp_feBlend, G_TYPE_OBJECT);
 
diff --git a/src/filters/colormatrix.cpp b/src/filters/colormatrix.cpp
index 889913e2e..ee27a85e6 100644
--- a/src/filters/colormatrix.cpp
+++ b/src/filters/colormatrix.cpp
@@ -29,6 +29,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-colormatrix.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createColorMatrix() {
+		return new SPFeColorMatrix();
+	}
+
+	bool colorMatrixRegistered = SPFactory::instance().registerObject("svg:feColorMatrix", createColorMatrix);
+}
+
 /* FeColorMatrix base class */
 G_DEFINE_TYPE(SPFeColorMatrix, sp_feColorMatrix, G_TYPE_OBJECT);
 
diff --git a/src/filters/componenttransfer.cpp b/src/filters/componenttransfer.cpp
index ec1cdb641..0a35c9a14 100644
--- a/src/filters/componenttransfer.cpp
+++ b/src/filters/componenttransfer.cpp
@@ -27,6 +27,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-component-transfer.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createComponentTransfer() {
+		return new SPFeComponentTransfer();
+	}
+
+	bool componentTransferRegistered = SPFactory::instance().registerObject("svg:feComponentTransfer", createComponentTransfer);
+}
+
 /* FeComponentTransfer base class */
 G_DEFINE_TYPE(SPFeComponentTransfer, sp_feComponentTransfer, G_TYPE_OBJECT);
 
diff --git a/src/filters/composite.cpp b/src/filters/composite.cpp
index cddcc86bd..a6bf107d9 100644
--- a/src/filters/composite.cpp
+++ b/src/filters/composite.cpp
@@ -25,6 +25,16 @@
 #include "display/nr-filter-composite.h"
 #include "sp-filter.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createComposite() {
+		return new SPFeComposite();
+	}
+
+	bool compositeRegistered = SPFactory::instance().registerObject("svg:feComposite", createComposite);
+}
+
 /* FeComposite base class */
 G_DEFINE_TYPE(SPFeComposite, sp_feComposite, G_TYPE_OBJECT);
 
diff --git a/src/filters/convolvematrix.cpp b/src/filters/convolvematrix.cpp
index 174c74288..d1be96a73 100644
--- a/src/filters/convolvematrix.cpp
+++ b/src/filters/convolvematrix.cpp
@@ -28,6 +28,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-convolve-matrix.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createConvolveMatrix() {
+		return new SPFeConvolveMatrix();
+	}
+
+	bool convolveMatrixRegistered = SPFactory::instance().registerObject("svg:feConvolveMatrix", createConvolveMatrix);
+}
+
 /* FeConvolveMatrix base class */
 G_DEFINE_TYPE(SPFeConvolveMatrix, sp_feConvolveMatrix, G_TYPE_OBJECT);
 
diff --git a/src/filters/diffuselighting.cpp b/src/filters/diffuselighting.cpp
index b53451f73..8cdd5e76b 100644
--- a/src/filters/diffuselighting.cpp
+++ b/src/filters/diffuselighting.cpp
@@ -36,6 +36,16 @@
 /* FeDiffuseLighting base class */
 static void sp_feDiffuseLighting_children_modified(SPFeDiffuseLighting *sp_diffuselighting);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createDiffuseLighting() {
+		return new SPFeDiffuseLighting();
+	}
+
+	bool diffuseLightingRegistered = SPFactory::instance().registerObject("svg:feDiffuseLighting", createDiffuseLighting);
+}
+
 G_DEFINE_TYPE(SPFeDiffuseLighting, sp_feDiffuseLighting, G_TYPE_OBJECT);
 
 static void
diff --git a/src/filters/displacementmap.cpp b/src/filters/displacementmap.cpp
index 79431c251..b192083c1 100644
--- a/src/filters/displacementmap.cpp
+++ b/src/filters/displacementmap.cpp
@@ -25,6 +25,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-displacement-map.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createDisplacementMap() {
+		return new SPFeDisplacementMap();
+	}
+
+	bool displacementMapRegistered = SPFactory::instance().registerObject("svg:feDisplacementMap", createDisplacementMap);
+}
+
 /* FeDisplacementMap base class */
 G_DEFINE_TYPE(SPFeDisplacementMap, sp_feDisplacementMap, G_TYPE_OBJECT);
 
diff --git a/src/filters/flood.cpp b/src/filters/flood.cpp
index 7d8df14fb..eb24d2748 100644
--- a/src/filters/flood.cpp
+++ b/src/filters/flood.cpp
@@ -27,6 +27,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-flood.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFlood() {
+		return new SPFeFlood();
+	}
+
+	bool floodRegistered = SPFactory::instance().registerObject("svg:feFlood", createFlood);
+}
+
 /* FeFlood base class */
 G_DEFINE_TYPE(SPFeFlood, sp_feFlood, G_TYPE_OBJECT);
 
diff --git a/src/filters/gaussian-blur.cpp b/src/filters/gaussian-blur.cpp
index 643b695e6..f66e045f2 100644
--- a/src/filters/gaussian-blur.cpp
+++ b/src/filters/gaussian-blur.cpp
@@ -30,6 +30,16 @@
 //#define SP_MACROS_SILENT
 //#include "macros.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createGaussianBlur() {
+		return new SPGaussianBlur();
+	}
+
+	bool gaussianBlurRegistered = SPFactory::instance().registerObject("svg:feGaussianBlur", createGaussianBlur);
+}
+
 /* GaussianBlur base class */
 G_DEFINE_TYPE(SPGaussianBlur, sp_gaussianBlur, G_TYPE_OBJECT);
 
diff --git a/src/filters/image.cpp b/src/filters/image.cpp
index 6c8af9c01..e6d1eceec 100644
--- a/src/filters/image.cpp
+++ b/src/filters/image.cpp
@@ -29,6 +29,16 @@
 
 #include "display/nr-filter.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createImage() {
+		return new SPFeImage();
+	}
+
+	bool imageRegistered = SPFactory::instance().registerObject("svg:feImage", createImage);
+}
+
 /* FeImage base class */
 G_DEFINE_TYPE(SPFeImage, sp_feImage, G_TYPE_OBJECT);
 
diff --git a/src/filters/merge.cpp b/src/filters/merge.cpp
index 01fb4bb72..505f12887 100644
--- a/src/filters/merge.cpp
+++ b/src/filters/merge.cpp
@@ -24,6 +24,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-merge.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMerge() {
+		return new SPFeMerge();
+	}
+
+	bool mergeRegistered = SPFactory::instance().registerObject("svg:feMerge", createMerge);
+}
+
 /* FeMerge base class */
 G_DEFINE_TYPE(SPFeMerge, sp_feMerge, G_TYPE_OBJECT);
 
diff --git a/src/filters/mergenode.cpp b/src/filters/mergenode.cpp
index c1c5c6067..fbdcc9277 100644
--- a/src/filters/mergenode.cpp
+++ b/src/filters/mergenode.cpp
@@ -23,6 +23,16 @@
 #include "filters/merge.h"
 #include "display/nr-filter-types.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMergeNode() {
+		return new SPFeMergeNode();
+	}
+
+	bool mergeNodeRegistered = SPFactory::instance().registerObject("svg:feMergeNode", createMergeNode);
+}
+
 G_DEFINE_TYPE(SPFeMergeNode, sp_feMergeNode, G_TYPE_OBJECT);
 
 static void
diff --git a/src/filters/morphology.cpp b/src/filters/morphology.cpp
index 87d7dafdc..bbdb702c0 100644
--- a/src/filters/morphology.cpp
+++ b/src/filters/morphology.cpp
@@ -26,6 +26,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-morphology.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMorphology() {
+		return new SPFeMorphology();
+	}
+
+	bool morphologyRegistered = SPFactory::instance().registerObject("svg:feMorphology", createMorphology);
+}
+
 /* FeMorphology base class */
 G_DEFINE_TYPE(SPFeMorphology, sp_feMorphology, G_TYPE_OBJECT);
 
diff --git a/src/filters/offset.cpp b/src/filters/offset.cpp
index 26607e590..ce0490e0d 100644
--- a/src/filters/offset.cpp
+++ b/src/filters/offset.cpp
@@ -25,6 +25,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-offset.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createOffset() {
+		return new SPFeOffset();
+	}
+
+	bool offsetRegistered = SPFactory::instance().registerObject("svg:feOffset", createOffset);
+}
+
 /* FeOffset base class */
 G_DEFINE_TYPE(SPFeOffset, sp_feOffset, G_TYPE_OBJECT);
 
diff --git a/src/filters/pointlight.cpp b/src/filters/pointlight.cpp
index 749a4c82b..371166880 100644
--- a/src/filters/pointlight.cpp
+++ b/src/filters/pointlight.cpp
@@ -29,6 +29,16 @@
 #define SP_MACROS_SILENT
 #include "macros.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createpPointLight() {
+		return new SPFePointLight();
+	}
+
+	bool pointLightRegistered = SPFactory::instance().registerObject("svg:fePointLight", createPointLight);
+}
+
 G_DEFINE_TYPE(SPFePointLight, sp_fepointlight, G_TYPE_OBJECT);
 
 static void
diff --git a/src/filters/specularlighting.cpp b/src/filters/specularlighting.cpp
index 4b8fe96b6..1409bc88b 100644
--- a/src/filters/specularlighting.cpp
+++ b/src/filters/specularlighting.cpp
@@ -36,6 +36,16 @@
 /* FeSpecularLighting base class */
 static void sp_feSpecularLighting_children_modified(SPFeSpecularLighting *sp_specularlighting);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createSpecularLighting() {
+		return new SPFeSpecularLighting();
+	}
+
+	bool specularLightingRegistered = SPFactory::instance().registerObject("svg:feSpecularLighting", createSpecularLighting);
+}
+
 G_DEFINE_TYPE(SPFeSpecularLighting, sp_feSpecularLighting, G_TYPE_OBJECT);
 
 static void
diff --git a/src/filters/spotlight.cpp b/src/filters/spotlight.cpp
index a1cff9db9..9e89139e3 100644
--- a/src/filters/spotlight.cpp
+++ b/src/filters/spotlight.cpp
@@ -29,6 +29,16 @@
 #define SP_MACROS_SILENT
 #include "macros.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createSpotLight() {
+		return new SPFeSpotLight();
+	}
+
+	bool spotLightRegistered = SPFactory::instance().registerObject("svg:feSpotLight", createSpotLight);
+}
+
 G_DEFINE_TYPE(SPFeSpotLight, sp_fespotlight, G_TYPE_OBJECT);
 
 static void
diff --git a/src/filters/tile.cpp b/src/filters/tile.cpp
index 8aefc14c6..f6b4c00d6 100644
--- a/src/filters/tile.cpp
+++ b/src/filters/tile.cpp
@@ -22,6 +22,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-tile.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createTile() {
+		return new SPFeTile();
+	}
+
+	bool tileRegistered = SPFactory::instance().registerObject("svg:feTile", createTile);
+}
+
 /* FeTile base class */
 G_DEFINE_TYPE(SPFeTile, sp_feTile, G_TYPE_OBJECT);
 
diff --git a/src/filters/turbulence.cpp b/src/filters/turbulence.cpp
index 758322b9f..8aa168114 100644
--- a/src/filters/turbulence.cpp
+++ b/src/filters/turbulence.cpp
@@ -28,6 +28,16 @@
 #include "display/nr-filter.h"
 #include "display/nr-filter-turbulence.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createTurbulence() {
+		return new SPFeTurbulence();
+	}
+
+	bool turbulenceRegistered = SPFactory::instance().registerObject("svg:feTurbulence", createTurbulence);
+}
+
 /* FeTurbulence base class */
 G_DEFINE_TYPE(SPFeTurbulence, sp_feTurbulence, G_TYPE_OBJECT);
 
diff --git a/src/live_effects/lpeobject.cpp b/src/live_effects/lpeobject.cpp
index 15a8a26b6..5191d612c 100644
--- a/src/live_effects/lpeobject.cpp
+++ b/src/live_effects/lpeobject.cpp
@@ -20,6 +20,16 @@
 
 //#define LIVEPATHEFFECT_VERBOSE
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createLivepatheffect() {
+		return new LivePathEffectObject();
+	}
+
+	bool livepatheffectRegistered = SPFactory::instance().registerObject("inkscape:path-effect", createLivepatheffect);
+}
+
 static void livepatheffect_on_repr_attr_changed (Inkscape::XML::Node * repr, const gchar *key, const gchar *oldval, const gchar *newval, bool is_interactive, void * data);
 
 static SPObjectClass *livepatheffect_parent_class;
diff --git a/src/marker.cpp b/src/marker.cpp
index ef2aeaae5..7b824c196 100644
--- a/src/marker.cpp
+++ b/src/marker.cpp
@@ -42,6 +42,16 @@ static void sp_marker_print (SPItem *item, SPPrintContext *ctx);
 
 static void sp_marker_view_remove (SPMarker *marker, SPMarkerView *view, unsigned int destroyitems);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMarker() {
+		return new SPMarker();
+	}
+
+	bool markerRegistered = SPFactory::instance().registerObject("svg:marker", createMarker);
+}
+
 G_DEFINE_TYPE(SPMarker, sp_marker, G_TYPE_OBJECT);
 
 /**
diff --git a/src/persp3d.cpp b/src/persp3d.cpp
index 2d67ac1a2..97898daf2 100644
--- a/src/persp3d.cpp
+++ b/src/persp3d.cpp
@@ -34,6 +34,16 @@ static gchar * persp3d_pt_to_str (Persp3DImpl *persp_impl, Proj::Axis const axis
 
 static int global_counter = 0;
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createPersp3D() {
+		return new Persp3D();
+	}
+
+	bool persp3DRegistered = SPFactory::instance().registerObject("inkscape:persp3d", createPersp3D);
+}
+
 /* Constructor/destructor for the internal class */
 
 Persp3DImpl::Persp3DImpl() {
diff --git a/src/sp-anchor.cpp b/src/sp-anchor.cpp
index 8a1feb61d..df2669ebf 100644
--- a/src/sp-anchor.cpp
+++ b/src/sp-anchor.cpp
@@ -25,6 +25,16 @@
 #include "ui/view/view.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createAnchor() {
+		return new SPAnchor();
+	}
+
+	bool anchorRegistered = SPFactory::instance().registerObject("svg:a", createAnchor);
+}
+
 G_DEFINE_TYPE(SPAnchor, sp_anchor, G_TYPE_OBJECT);
 
 static void sp_anchor_class_init(SPAnchorClass *ac)
diff --git a/src/sp-clippath.cpp b/src/sp-clippath.cpp
index ff12f9678..496a4ed82 100644
--- a/src/sp-clippath.cpp
+++ b/src/sp-clippath.cpp
@@ -40,6 +40,16 @@ struct SPClipPathView {
 static SPClipPathView*      sp_clippath_view_new_prepend(SPClipPathView *list, unsigned int key, Inkscape::DrawingItem *arenaitem);
 static SPClipPathView*      sp_clippath_view_list_remove(SPClipPathView *list, SPClipPathView *view);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createClipPath() {
+		return new SPClipPath();
+	}
+
+	bool clipPathRegistered = SPFactory::instance().registerObject("svg:clipPath", createClipPath);
+}
+
 G_DEFINE_TYPE(SPClipPath, sp_clippath, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-defs.cpp b/src/sp-defs.cpp
index d73b6db74..a385dca6a 100644
--- a/src/sp-defs.cpp
+++ b/src/sp-defs.cpp
@@ -20,6 +20,15 @@
 #include "xml/repr.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createDefs() {
+		return new SPDefs();
+	}
+
+	bool defsRegistered = SPFactory::instance().registerObject("svg:defs", createDefs);
+}
 
 G_DEFINE_TYPE(SPDefs, sp_defs, G_TYPE_OBJECT);
 
diff --git a/src/sp-desc.cpp b/src/sp-desc.cpp
index 81b4240bb..0fe1f5305 100644
--- a/src/sp-desc.cpp
+++ b/src/sp-desc.cpp
@@ -16,6 +16,16 @@
 #include "sp-desc.h"
 #include "xml/repr.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createDesc() {
+		return new SPDesc();
+	}
+
+	bool descRegistered = SPFactory::instance().registerObject("svg:desc", createDesc);
+}
+
 G_DEFINE_TYPE(SPDesc, sp_desc, SP_TYPE_OBJECT);
 
 static void sp_desc_class_init(SPDescClass *klass)
diff --git a/src/sp-ellipse.cpp b/src/sp-ellipse.cpp
index a2c94c508..66c7a81a8 100644
--- a/src/sp-ellipse.cpp
+++ b/src/sp-ellipse.cpp
@@ -35,6 +35,28 @@
 
 #define noELLIPSE_VERBOSE
 
+
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createEllipse() {
+		return new SPEllipse();
+	}
+
+	SPObject* createCircle() {
+		return new SPCircle();
+	}
+
+	SPObject* createArc() {
+		return new SPArc();
+	}
+
+	bool ellipseRegistered = SPFactory::instance().registerObject("svg:ellipse", createEllipse);
+	bool circleRegistered = SPFactory::instance().registerObject("svg:circle", createCircle);
+	bool arcRegistered = SPFactory::instance().registerObject("arc", createArc);
+}
+
+
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
diff --git a/src/sp-filter.cpp b/src/sp-filter.cpp
index 998c28865..db1887715 100644
--- a/src/sp-filter.cpp
+++ b/src/sp-filter.cpp
@@ -41,6 +41,16 @@ using std::pair;
 static void filter_ref_changed(SPObject *old_ref, SPObject *ref, SPFilter *filter);
 static void filter_ref_modified(SPObject *href, guint flags, SPFilter *filter);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFilter() {
+		return new SPFilter();
+	}
+
+	bool filterRegistered = SPFactory::instance().registerObject("svg:filter", createFilter);
+}
+
 G_DEFINE_TYPE(SPFilter, sp_filter, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-flowdiv.cpp b/src/sp-flowdiv.cpp
index 329391352..6c8f2c4e2 100644
--- a/src/sp-flowdiv.cpp
+++ b/src/sp-flowdiv.cpp
@@ -20,6 +20,36 @@ static void sp_flowpara_init (SPFlowpara *group);
 static void sp_flowline_init (SPFlowline *group);
 static void sp_flowregionbreak_init (SPFlowregionbreak *group);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFlowdiv() {
+		return new SPFlowdiv();
+	}
+
+	SPObject* createFlowtspan() {
+		return new SPFlowtspan();
+	}
+
+	SPObject* createFlowpara() {
+		return new SPFlowpara();
+	}
+
+	SPObject* createFlowline() {
+		return new SPFlowline();
+	}
+
+	SPObject* createFlowregionbreak() {
+		return new SPFlowregionbreak();
+	}
+
+	bool flowdivRegistered = SPFactory::instance().registerObject("svg:flowDiv", createFlowdiv);
+	bool flowtspanRegistered = SPFactory::instance().registerObject("svg:flowSpan", createFlowtspan);
+	bool flowparaRegistered = SPFactory::instance().registerObject("svg:flowPara", createFlowpara);
+	bool flowlineRegistered = SPFactory::instance().registerObject("svg:flowLine", createFlowline);
+	bool flowregionbreakRegistered = SPFactory::instance().registerObject("svg:flowRegionBreak", createFlowregionbreak);
+}
+
 G_DEFINE_TYPE(SPFlowdiv, sp_flowdiv, G_TYPE_OBJECT);
 
 static void sp_flowdiv_class_init(SPFlowdivClass *klass)
diff --git a/src/sp-flowregion.cpp b/src/sp-flowregion.cpp
index 29ce4e7a9..bc9f6aeda 100644
--- a/src/sp-flowregion.cpp
+++ b/src/sp-flowregion.cpp
@@ -27,6 +27,21 @@
 static void sp_flowregion_init (SPFlowregion *group);
 static void sp_flowregion_dispose (GObject *object);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFlowregion() {
+		return new SPFlowregion();
+	}
+
+	SPObject* createFlowregionExclude() {
+		return new SPFlowregionExclude();
+	}
+
+	bool flowregionRegistered = SPFactory::instance().registerObject("svg:flowRegion", createFlowregion);
+	bool flowregionExcludeRegistered = SPFactory::instance().registerObject("svg:flowRegionExclude", createFlowregionExclude);
+}
+
 G_DEFINE_TYPE(SPFlowregion, sp_flowregion, G_TYPE_OBJECT);
 
 static void sp_flowregionexclude_init (SPFlowregionExclude *group);
diff --git a/src/sp-flowtext.cpp b/src/sp-flowtext.cpp
index 8b6cf4a25..1d08b8256 100644
--- a/src/sp-flowtext.cpp
+++ b/src/sp-flowtext.cpp
@@ -37,6 +37,16 @@
 static void sp_flowtext_init(SPFlowtext *group);
 static void sp_flowtext_dispose(GObject *object);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFlowtext() {
+		return new SPFlowtext();
+	}
+
+	bool flowtextRegistered = SPFactory::instance().registerObject("svg:flowRoot", createFlowtext);
+}
+
 G_DEFINE_TYPE(SPFlowtext, sp_flowtext, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-font-face.cpp b/src/sp-font-face.cpp
index d946c4f20..6149d9af0 100644
--- a/src/sp-font-face.cpp
+++ b/src/sp-font-face.cpp
@@ -259,6 +259,16 @@ static std::vector<FontFaceStretchType> sp_read_fontFaceStretchType(gchar const
     return v;
 }
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFontFace() {
+		return new SPFontFace();
+	}
+
+	bool fontFaceRegistered = SPFactory::instance().registerObject("svg:font-face", createFontFace);
+}
+
 G_DEFINE_TYPE(SPFontFace, sp_fontface, G_TYPE_OBJECT);
 
 static void sp_fontface_class_init(SPFontFaceClass *fc)
diff --git a/src/sp-font.cpp b/src/sp-font.cpp
index d7eafe84e..ed91dc6e7 100644
--- a/src/sp-font.cpp
+++ b/src/sp-font.cpp
@@ -23,6 +23,16 @@
 
 #include "display/nr-svgfonts.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createFont() {
+		return new SPFont();
+	}
+
+	bool fontRegistered = SPFactory::instance().registerObject("svg:font", createFont);
+}
+
 G_DEFINE_TYPE(SPFont, sp_font, G_TYPE_OBJECT);
 
 static void sp_font_class_init(SPFontClass *fc)
diff --git a/src/sp-glyph.cpp b/src/sp-glyph.cpp
index 2ab62c575..85c7beb4f 100644
--- a/src/sp-glyph.cpp
+++ b/src/sp-glyph.cpp
@@ -22,6 +22,16 @@
 #include "document.h"
 #include <cstring>
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createGlyph() {
+		return new SPGlyph();
+	}
+
+	bool glyphRegistered = SPFactory::instance().registerObject("svg:glyph", createGlyph);
+}
+
 G_DEFINE_TYPE(SPGlyph, sp_glyph, G_TYPE_OBJECT);
 
 static void sp_glyph_class_init(SPGlyphClass *gc)
diff --git a/src/sp-gradient.cpp b/src/sp-gradient.cpp
index 1a1b1b1e6..70e90f33c 100644
--- a/src/sp-gradient.cpp
+++ b/src/sp-gradient.cpp
@@ -60,6 +60,42 @@
 /// Has to be power of 2   Seems to be unused.
 //#define NCOLORS NR_GRADIENT_VECTOR_LENGTH
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createStop() {
+		return new SPStop();
+	}
+
+	SPObject* createMeshRow() {
+		return new SPMeshRow();
+	}
+
+	SPObject* createMeshPatch() {
+		return new SPMeshPatch();
+	}
+
+	SPObject* createLinearGradient() {
+		return new SPLinearGradient();
+	}
+
+	SPObject* createRadialGradient() {
+		return new SPRadialGradient();
+	}
+
+	SPObject* createMeshGradient() {
+		return new SPMeshGradient();
+	}
+
+	bool stopRegistered = SPFactory::instance().registerObject("svg:stop", createStop);
+	bool meshRowRegistered = SPFactory::instance().registerObject("svg:meshRow", createMeshRow);
+	bool meshPatchRegistered = SPFactory::instance().registerObject("svg:meshPatch", createMeshPatch);
+	bool linearGradientRegistered = SPFactory::instance().registerObject("svg:linearGradient", createLinearGradient);
+	bool radialGradientRegistered = SPFactory::instance().registerObject("svg:radialGradient", createRadialGradient);
+	bool meshGradientRegistered = SPFactory::instance().registerObject("svg:meshGradient", createMeshGradient);
+}
+
+
 // SPStop
 G_DEFINE_TYPE(SPStop, sp_stop, G_TYPE_OBJECT);
 
diff --git a/src/sp-image.cpp b/src/sp-image.cpp
index ecae573e6..8cba1e87a 100644
--- a/src/sp-image.cpp
+++ b/src/sp-image.cpp
@@ -499,6 +499,17 @@ GdkPixbuf* pixbuf_new_from_file( const char *filename, GError **error )
 }
 }
 
+
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createImage() {
+		return new SPImage();
+	}
+
+	bool imageRegistered = SPFactory::instance().registerObject("svg:image", createImage);
+}
+
 G_DEFINE_TYPE(SPImage, sp_image, G_TYPE_OBJECT);
 
 static void sp_image_class_init( SPImageClass * klass )
diff --git a/src/sp-item-group.cpp b/src/sp-item-group.cpp
index 0dbb078dd..10e84f2da 100644
--- a/src/sp-item-group.cpp
+++ b/src/sp-item-group.cpp
@@ -57,6 +57,16 @@ static void sp_group_dispose(GObject *object);
 
 static void sp_group_perform_patheffect(SPGroup *group, SPGroup *topgroup, bool write);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createGroup() {
+		return new SPGroup();
+	}
+
+	bool groupRegistered = SPFactory::instance().registerObject("svg:g", createGroup);
+}
+
 G_DEFINE_TYPE(SPGroup, sp_group, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-line.cpp b/src/sp-line.cpp
index b6677baf3..d7ffa8307 100644
--- a/src/sp-line.cpp
+++ b/src/sp-line.cpp
@@ -24,6 +24,15 @@
 #include "document.h"
 #include "inkscape.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createLine() {
+		return new SPLine();
+	}
+
+	bool lineRegistered = SPFactory::instance().registerObject("svg:line", createLine);
+}
 
 G_DEFINE_TYPE(SPLine, sp_line, G_TYPE_OBJECT);
 
diff --git a/src/sp-mask.cpp b/src/sp-mask.cpp
index cb91418b6..014d40a6a 100644
--- a/src/sp-mask.cpp
+++ b/src/sp-mask.cpp
@@ -37,6 +37,16 @@ struct SPMaskView {
 SPMaskView *sp_mask_view_new_prepend (SPMaskView *list, unsigned int key, Inkscape::DrawingItem *arenaitem);
 SPMaskView *sp_mask_view_list_remove (SPMaskView *list, SPMaskView *view);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMask() {
+		return new SPMask();
+	}
+
+	bool maskRegistered = SPFactory::instance().registerObject("svg:mask", createMask);
+}
+
 G_DEFINE_TYPE(SPMask, sp_mask, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-metadata.cpp b/src/sp-metadata.cpp
index 40ed0c603..12973191f 100644
--- a/src/sp-metadata.cpp
+++ b/src/sp-metadata.cpp
@@ -33,6 +33,16 @@
 
 /* Metadata base class */
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMetadata() {
+		return new SPMetadata();
+	}
+
+	bool metadataRegistered = SPFactory::instance().registerObject("svg:metadata", createMetadata);
+}
+
 G_DEFINE_TYPE(SPMetadata, sp_metadata, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp
index c1db6e26d..1a67a49ad 100644
--- a/src/sp-missing-glyph.cpp
+++ b/src/sp-missing-glyph.cpp
@@ -19,6 +19,16 @@
 #include "sp-missing-glyph.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createMissingGlyph() {
+		return new SPMissingGlyph();
+	}
+
+	bool missingGlyphRegistered = SPFactory::instance().registerObject("svg:missing-glyph", createMissingGlyph);
+}
+
 G_DEFINE_TYPE(SPMissingGlyph, sp_missing_glyph, G_TYPE_OBJECT);
 
 static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc)
diff --git a/src/sp-object-repr.cpp b/src/sp-object-repr.cpp
index eba38ec67..02114aabc 100644
--- a/src/sp-object-repr.cpp
+++ b/src/sp-object-repr.cpp
@@ -130,93 +130,93 @@ populate_dtables()
 {
     struct NameTypeEntry { char const *const name; GType const type_id; };
     NameTypeEntry const repr_name_entries[] = {
-        { "svg:a", SP_TYPE_ANCHOR },
+        //{ "svg:a", SP_TYPE_ANCHOR },
         //{ "svg:animate", SP_TYPE_ANIMATE },
-        { "svg:circle", SP_TYPE_CIRCLE },
-        { "svg:color-profile", COLORPROFILE_TYPE },
-        { "svg:clipPath", SP_TYPE_CLIPPATH },
-        { "svg:defs", SP_TYPE_DEFS },
-        { "svg:desc", SP_TYPE_DESC },
-        { "svg:ellipse", SP_TYPE_ELLIPSE },
-        { "svg:filter", SP_TYPE_FILTER },
+        //{ "svg:circle", SP_TYPE_CIRCLE },
+        //{ "svg:color-profile", COLORPROFILE_TYPE },
+        //{ "svg:clipPath", SP_TYPE_CLIPPATH },
+        //{ "svg:defs", SP_TYPE_DEFS },
+        //{ "svg:desc", SP_TYPE_DESC },
+        //{ "svg:ellipse", SP_TYPE_ELLIPSE },
+        //{ "svg:filter", SP_TYPE_FILTER },
         /* Note: flow* elements are proposed additions for SVG 1.2, they aren't in
            SVG 1.1. */
-        { "svg:flowDiv", SP_TYPE_FLOWDIV },
-        { "svg:flowLine", SP_TYPE_FLOWLINE },
-        { "svg:flowPara", SP_TYPE_FLOWPARA },
-        { "svg:flowRegion", SP_TYPE_FLOWREGION },
-        { "svg:flowRegionBreak", SP_TYPE_FLOWREGIONBREAK },
-        { "svg:flowRegionExclude", SP_TYPE_FLOWREGIONEXCLUDE },
-        { "svg:flowRoot", SP_TYPE_FLOWTEXT },
-        { "svg:flowSpan", SP_TYPE_FLOWTSPAN },
-        { "svg:font", SP_TYPE_FONT },
-        { "svg:font-face", SP_TYPE_FONTFACE },
-        { "svg:glyph", SP_TYPE_GLYPH },
-        { "svg:missing-glyph", SP_TYPE_MISSING_GLYPH },
+        //{ "svg:flowDiv", SP_TYPE_FLOWDIV },
+        //{ "svg:flowLine", SP_TYPE_FLOWLINE },
+        //{ "svg:flowPara", SP_TYPE_FLOWPARA },
+        //{ "svg:flowRegion", SP_TYPE_FLOWREGION },
+        //{ "svg:flowRegionBreak", SP_TYPE_FLOWREGIONBREAK },
+        //{ "svg:flowRegionExclude", SP_TYPE_FLOWREGIONEXCLUDE },
+        //{ "svg:flowRoot", SP_TYPE_FLOWTEXT },
+        //{ "svg:flowSpan", SP_TYPE_FLOWTSPAN },
+        //{ "svg:font", SP_TYPE_FONT },
+        //{ "svg:font-face", SP_TYPE_FONTFACE },
+        //{ "svg:glyph", SP_TYPE_GLYPH },
+        //{ "svg:missing-glyph", SP_TYPE_MISSING_GLYPH },
         { "svg:hkern", SP_TYPE_HKERN },
         { "svg:vkern", SP_TYPE_VKERN },
-        { "svg:g", SP_TYPE_GROUP },
-        { "svg:feBlend", SP_TYPE_FEBLEND },
-        { "svg:feColorMatrix", SP_TYPE_FECOLORMATRIX },
-        { "svg:feComponentTransfer", SP_TYPE_FECOMPONENTTRANSFER },
-        { "svg:feComposite", SP_TYPE_FECOMPOSITE },
-        { "svg:feConvolveMatrix", SP_TYPE_FECONVOLVEMATRIX },
-        { "svg:feDiffuseLighting", SP_TYPE_FEDIFFUSELIGHTING },
-        { "svg:feDistantLight", SP_TYPE_FEDISTANTLIGHT },
-        { "svg:feDisplacementMap", SP_TYPE_FEDISPLACEMENTMAP },
-        { "svg:feFlood", SP_TYPE_FEFLOOD },
+        //{ "svg:g", SP_TYPE_GROUP },
+        //{ "svg:feBlend", SP_TYPE_FEBLEND },
+        //{ "svg:feColorMatrix", SP_TYPE_FECOLORMATRIX },
+        //{ "svg:feComponentTransfer", SP_TYPE_FECOMPONENTTRANSFER },
+        //{ "svg:feComposite", SP_TYPE_FECOMPOSITE },
+        //{ "svg:feConvolveMatrix", SP_TYPE_FECONVOLVEMATRIX },
+        //{ "svg:feDiffuseLighting", SP_TYPE_FEDIFFUSELIGHTING },
+        //{ "svg:feDistantLight", SP_TYPE_FEDISTANTLIGHT },
+        //{ "svg:feDisplacementMap", SP_TYPE_FEDISPLACEMENTMAP },
+        //{ "svg:feFlood", SP_TYPE_FEFLOOD },
         { "svg:feFuncR", SP_TYPE_FEFUNCR },
         { "svg:feFuncG", SP_TYPE_FEFUNCG },
         { "svg:feFuncB", SP_TYPE_FEFUNCB },
         { "svg:feFuncA", SP_TYPE_FEFUNCA },
-        { "svg:feGaussianBlur", SP_TYPE_GAUSSIANBLUR },
-        { "svg:feImage", SP_TYPE_FEIMAGE },
-        { "svg:feMerge", SP_TYPE_FEMERGE },
-        { "svg:feMorphology", SP_TYPE_FEMORPHOLOGY },
-        { "svg:feOffset", SP_TYPE_FEOFFSET },
-        { "svg:fePointLight", SP_TYPE_FEPOINTLIGHT },
-        { "svg:feSpecularLighting", SP_TYPE_FESPECULARLIGHTING },
-        { "svg:feSpotLight", SP_TYPE_FESPOTLIGHT },
-        { "svg:feTile", SP_TYPE_FETILE },
-        { "svg:feTurbulence", SP_TYPE_FETURBULENCE },
-        { "svg:feMergeNode", SP_TYPE_FEMERGENODE },
-        { "svg:image", SP_TYPE_IMAGE },
-        { "svg:line", SP_TYPE_LINE },
-        { "svg:linearGradient", SP_TYPE_LINEARGRADIENT },
-        { "svg:marker", SP_TYPE_MARKER },
-        { "svg:mask", SP_TYPE_MASK },
-        { "svg:meshGradient", SP_TYPE_MESHGRADIENT },
-        { "svg:meshRow", SP_TYPE_MESHROW },
-        { "svg:meshPatch", SP_TYPE_MESHPATCH },
-        { "svg:metadata", SP_TYPE_METADATA },
-        { "svg:path", SP_TYPE_PATH },
-        { "svg:pattern", SP_TYPE_PATTERN },
-        { "svg:polygon", SP_TYPE_POLYGON },
-        { "svg:polyline", SP_TYPE_POLYLINE },
-        { "svg:radialGradient", SP_TYPE_RADIALGRADIENT },
-        { "svg:rect", SP_TYPE_RECT },
-        { "svg:stop", SP_TYPE_STOP },
-        { "svg:script", SP_TYPE_SCRIPT },
-        { "svg:svg", SP_TYPE_ROOT },
-        { "svg:style", SP_TYPE_STYLE_ELEM },
-        { "svg:switch", SP_TYPE_SWITCH },
-        { "svg:symbol", SP_TYPE_SYMBOL },
-        { "svg:text", SP_TYPE_TEXT },
-        { "svg:textPath", SP_TYPE_TEXTPATH },
-        { "svg:title", SP_TYPE_TITLE },
-        { "svg:tref", SP_TYPE_TREF },
-        { "svg:tspan", SP_TYPE_TSPAN },
-        { "svg:use", SP_TYPE_USE },
-        { "inkscape:path-effect", TYPE_LIVEPATHEFFECT }
+        //{ "svg:feGaussianBlur", SP_TYPE_GAUSSIANBLUR },
+        //{ "svg:feImage", SP_TYPE_FEIMAGE },
+        //{ "svg:feMerge", SP_TYPE_FEMERGE },
+        //{ "svg:feMorphology", SP_TYPE_FEMORPHOLOGY },
+        //{ "svg:feOffset", SP_TYPE_FEOFFSET },
+        //{ "svg:fePointLight", SP_TYPE_FEPOINTLIGHT },
+        //{ "svg:feSpecularLighting", SP_TYPE_FESPECULARLIGHTING },
+        //{ "svg:feSpotLight", SP_TYPE_FESPOTLIGHT },
+        //{ "svg:feTile", SP_TYPE_FETILE },
+        //{ "svg:feTurbulence", SP_TYPE_FETURBULENCE },
+        //{ "svg:feMergeNode", SP_TYPE_FEMERGENODE },
+        //{ "svg:image", SP_TYPE_IMAGE },
+        //{ "svg:line", SP_TYPE_LINE },
+        //{ "svg:linearGradient", SP_TYPE_LINEARGRADIENT },
+        //{ "svg:marker", SP_TYPE_MARKER },
+        //{ "svg:mask", SP_TYPE_MASK },
+        //{ "svg:meshGradient", SP_TYPE_MESHGRADIENT },
+        //{ "svg:meshRow", SP_TYPE_MESHROW },
+        //{ "svg:meshPatch", SP_TYPE_MESHPATCH },
+        //{ "svg:metadata", SP_TYPE_METADATA },
+        //{ "svg:path", SP_TYPE_PATH },
+        //{ "svg:pattern", SP_TYPE_PATTERN },
+        //{ "svg:polygon", SP_TYPE_POLYGON },
+        //{ "svg:polyline", SP_TYPE_POLYLINE },
+        //{ "svg:radialGradient", SP_TYPE_RADIALGRADIENT },
+        //{ "svg:rect", SP_TYPE_RECT },
+        //{ "svg:stop", SP_TYPE_STOP },
+        //{ "svg:script", SP_TYPE_SCRIPT },
+        //{ "svg:svg", SP_TYPE_ROOT },
+        //{ "svg:style", SP_TYPE_STYLE_ELEM },
+        //{ "svg:switch", SP_TYPE_SWITCH },
+        //{ "svg:symbol", SP_TYPE_SYMBOL },
+        //{ "svg:text", SP_TYPE_TEXT },
+        //{ "svg:textPath", SP_TYPE_TEXTPATH },
+        //{ "svg:title", SP_TYPE_TITLE },
+        //{ "svg:tref", SP_TYPE_TREF },
+        //{ "svg:tspan", SP_TYPE_TSPAN },
+        //{ "svg:use", SP_TYPE_USE },
+        //{ "inkscape:path-effect", TYPE_LIVEPATHEFFECT }
     };
     NameTypeEntry const sodipodi_name_entries[] = {
-        { "arc", SP_TYPE_ARC },
-        { "inkscape:offset", SP_TYPE_OFFSET },
-        { "spiral", SP_TYPE_SPIRAL },
-        { "star", SP_TYPE_STAR },
-        { "inkscape:box3d", SP_TYPE_BOX3D },
-        { "inkscape:box3dside", SP_TYPE_BOX3D_SIDE },
-        { "inkscape:persp3d", SP_TYPE_PERSP3D }
+        //{ "arc", SP_TYPE_ARC },
+        //{ "inkscape:offset", SP_TYPE_OFFSET },
+        //{ "spiral", SP_TYPE_SPIRAL },
+        //{ "star", SP_TYPE_STAR },
+        //{ "inkscape:box3d", SP_TYPE_BOX3D },
+        //{ "inkscape:box3dside", SP_TYPE_BOX3D_SIDE },
+        //{ "inkscape:persp3d", SP_TYPE_PERSP3D }
     };
 
     NameTypeEntry const *const t2entries[] = {
diff --git a/src/sp-offset.cpp b/src/sp-offset.cpp
index 3a8bf5a10..5a9b3933c 100644
--- a/src/sp-offset.cpp
+++ b/src/sp-offset.cpp
@@ -43,6 +43,16 @@
 
 class SPDocument;
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createOffset() {
+		return new SPOffset();
+	}
+
+	bool offsetRegistered = SPFactory::instance().registerObject("inkscape:offset", createOffset);
+}
+
 #define noOFFSET_VERBOSE
 
 /** \note
diff --git a/src/sp-path.cpp b/src/sp-path.cpp
index 132415e51..bc6a2cb21 100644
--- a/src/sp-path.cpp
+++ b/src/sp-path.cpp
@@ -51,6 +51,17 @@
 
 #define noPATH_VERBOSE
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createPath() {
+		return new SPPath();
+	}
+
+	bool pathRegistered = SPFactory::instance().registerObject("svg:path", createPath);
+}
+
+
 static void sp_path_finalize(GObject *obj);
 
 G_DEFINE_TYPE(SPPath, sp_path, G_TYPE_OBJECT);
diff --git a/src/sp-pattern.cpp b/src/sp-pattern.cpp
index a9b8ae2ed..e4132ac1d 100644
--- a/src/sp-pattern.cpp
+++ b/src/sp-pattern.cpp
@@ -43,6 +43,16 @@
 static void pattern_ref_changed(SPObject *old_ref, SPObject *ref, SPPattern *pat);
 static void pattern_ref_modified (SPObject *ref, guint flags, SPPattern *pattern);
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createPattern() {
+		return new SPPattern();
+	}
+
+	bool patternRegistered = SPFactory::instance().registerObject("svg:pattern", createPattern);
+}
+
 G_DEFINE_TYPE(SPPattern, sp_pattern, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-polygon.cpp b/src/sp-polygon.cpp
index dd09663c7..5b84c0bec 100644
--- a/src/sp-polygon.cpp
+++ b/src/sp-polygon.cpp
@@ -25,6 +25,16 @@
 #include "xml/repr.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createPolygon() {
+		return new SPPolygon();
+	}
+
+	bool polygonRegistered = SPFactory::instance().registerObject("svg:polygon", createPolygon);
+}
+
 G_DEFINE_TYPE(SPPolygon, sp_polygon, G_TYPE_OBJECT);
 
 static void sp_polygon_class_init(SPPolygonClass *pc)
diff --git a/src/sp-polyline.cpp b/src/sp-polyline.cpp
index 83d1265df..efa2bf874 100644
--- a/src/sp-polyline.cpp
+++ b/src/sp-polyline.cpp
@@ -20,6 +20,15 @@
 #include "xml/repr.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createPolyLine() {
+		return new SPPolyLine();
+	}
+
+	bool polyLineRegistered = SPFactory::instance().registerObject("svg:polyline", createPolyLine);
+}
 
 G_DEFINE_TYPE(SPPolyLine, sp_polyline, G_TYPE_OBJECT);
 
diff --git a/src/sp-rect.cpp b/src/sp-rect.cpp
index 3d06e8304..833e87020 100644
--- a/src/sp-rect.cpp
+++ b/src/sp-rect.cpp
@@ -31,6 +31,17 @@
 
 #define noRECT_VERBOSE
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createRect() {
+		return new SPRect();
+	}
+
+	bool rectRegistered = SPFactory::instance().registerObject("svg:rect", createRect);
+}
+
+
 G_DEFINE_TYPE(SPRect, sp_rect, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-root.cpp b/src/sp-root.cpp
index ac2ffdbf7..8dcae05be 100644
--- a/src/sp-root.cpp
+++ b/src/sp-root.cpp
@@ -31,6 +31,16 @@
 #include "svg/svg.h"
 #include "xml/repr.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createRoot() {
+		return new SPRoot();
+	}
+
+	bool rootRegistered = SPFactory::instance().registerObject("svg:svg", createRoot);
+}
+
 G_DEFINE_TYPE(SPRoot, sp_root, G_TYPE_OBJECT);
 
 /**
diff --git a/src/sp-script.cpp b/src/sp-script.cpp
index 0c286e276..5d706a17e 100644
--- a/src/sp-script.cpp
+++ b/src/sp-script.cpp
@@ -16,6 +16,16 @@
 #include <cstring>
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createScript() {
+		return new SPScript();
+	}
+
+	bool scriptRegistered = SPFactory::instance().registerObject("svg:script", createScript);
+}
+
 G_DEFINE_TYPE(SPScript, sp_script, G_TYPE_OBJECT);
 
 static void sp_script_class_init(SPScriptClass *sc)
diff --git a/src/sp-spiral.cpp b/src/sp-spiral.cpp
index eec5e953e..dabd9cdd0 100644
--- a/src/sp-spiral.cpp
+++ b/src/sp-spiral.cpp
@@ -28,6 +28,18 @@
 
 #include "sp-spiral.h"
 
+
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createSpiral() {
+		return new SPSpiral();
+	}
+
+	bool spiralRegistered = SPFactory::instance().registerObject("spiral", createSpiral);
+}
+
+
 G_DEFINE_TYPE(SPSpiral, sp_spiral, G_TYPE_OBJECT);
 
 /**
diff --git a/src/sp-star.cpp b/src/sp-star.cpp
index 11e367faf..741591479 100644
--- a/src/sp-star.cpp
+++ b/src/sp-star.cpp
@@ -32,6 +32,16 @@
 
 #include "sp-star.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createStar() {
+		return new SPStar();
+	}
+
+	bool starRegistered = SPFactory::instance().registerObject("star", createStar);
+}
+
 G_DEFINE_TYPE(SPStar, sp_star, G_TYPE_OBJECT);
 
 static void sp_star_class_init(SPStarClass *klass)
diff --git a/src/sp-style-elem.cpp b/src/sp-style-elem.cpp
index ac5d767f7..e130b677b 100644
--- a/src/sp-style-elem.cpp
+++ b/src/sp-style-elem.cpp
@@ -7,6 +7,16 @@
 #include "style.h"
 using Inkscape::XML::TEXT_NODE;
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createStyle() {
+		return new SPStyleElem();
+	}
+
+	bool styleRegistered = SPFactory::instance().registerObject("svg:style", createStyle);
+}
+
 G_DEFINE_TYPE(SPStyleElem, sp_style_elem, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-switch.cpp b/src/sp-switch.cpp
index fe5ae1db5..7dd5bf669 100644
--- a/src/sp-switch.cpp
+++ b/src/sp-switch.cpp
@@ -25,6 +25,16 @@
 #include <sigc++/functors/ptr_fun.h>
 #include <sigc++/adaptors/bind.h>
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createSwitch() {
+		return new SPSwitch();
+	}
+
+	bool switchRegistered = SPFactory::instance().registerObject("svg:switch", createSwitch);
+}
+
 G_DEFINE_TYPE(SPSwitch, sp_switch, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-symbol.cpp b/src/sp-symbol.cpp
index 6c1212d71..4e5b53e48 100644
--- a/src/sp-symbol.cpp
+++ b/src/sp-symbol.cpp
@@ -26,6 +26,16 @@
 #include "sp-symbol.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createSymbol() {
+		return new SPSymbol();
+	}
+
+	bool symbolRegistered = SPFactory::instance().registerObject("svg:symbol", createSymbol);
+}
+
 G_DEFINE_TYPE(SPSymbol, sp_symbol, G_TYPE_OBJECT);
 
 static void sp_symbol_class_init(SPSymbolClass *klass)
diff --git a/src/sp-text.cpp b/src/sp-text.cpp
index 6d9cd105d..f35b9bb3b 100644
--- a/src/sp-text.cpp
+++ b/src/sp-text.cpp
@@ -58,6 +58,16 @@
 #include "text-editing.h"
 #include "unit-constants.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createText() {
+		return new SPText();
+	}
+
+	bool textRegistered = SPFactory::instance().registerObject("svg:text", createText);
+}
+
 /*#####################################################
 #  SPTEXT
 #####################################################*/
diff --git a/src/sp-title.cpp b/src/sp-title.cpp
index a71b53e38..614d5033e 100644
--- a/src/sp-title.cpp
+++ b/src/sp-title.cpp
@@ -16,6 +16,16 @@
 #include "sp-title.h"
 #include "xml/repr.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createTitle() {
+		return new SPTitle();
+	}
+
+	bool titleRegistered = SPFactory::instance().registerObject("svg:title", createTitle);
+}
+
 G_DEFINE_TYPE(SPTitle, sp_title, G_TYPE_OBJECT);
 
 static void
diff --git a/src/sp-tref.cpp b/src/sp-tref.cpp
index 83b0746d8..22ebb5c17 100644
--- a/src/sp-tref.cpp
+++ b/src/sp-tref.cpp
@@ -35,6 +35,15 @@
 #include "xml/node.h"
 #include "xml/repr.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createTRef() {
+		return new SPTRef();
+	}
+
+	bool trefRegistered = SPFactory::instance().registerObject("svg:tref", createTRef);
+}
 
 //#define DEBUG_TREF
 #ifdef DEBUG_TREF
diff --git a/src/sp-tspan.cpp b/src/sp-tspan.cpp
index e9cc6f161..29786f244 100644
--- a/src/sp-tspan.cpp
+++ b/src/sp-tspan.cpp
@@ -43,6 +43,20 @@
 #include "xml/repr.h"
 #include "document.h"
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createTSpan() {
+		return new SPTSpan();
+	}
+
+	SPObject* createTextPath() {
+		return new SPTextPath();
+	}
+
+	bool tspanRegistered = SPFactory::instance().registerObject("svg:tspan", createTSpan);
+	bool textPathRegistered = SPFactory::instance().registerObject("svg:textPath", createTextPath);
+}
 
 /*#####################################################
 #  SPTSPAN
diff --git a/src/sp-use.cpp b/src/sp-use.cpp
index f146ef1db..5b1a1e880 100644
--- a/src/sp-use.cpp
+++ b/src/sp-use.cpp
@@ -47,6 +47,16 @@ static void sp_use_delete_self(SPObject *deleted, SPUse *self);
 //void m_print(gchar *say, Geom::Affine m)
 //{ g_print("%s %g %g %g %g %g %g\n", say, m[0], m[1], m[2], m[3], m[4], m[5]); }
 
+#include "sp-factory.h"
+
+namespace {
+	SPObject* createUse() {
+		return new SPUse();
+	}
+
+	bool useRegistered = SPFactory::instance().registerObject("svg:use", createUse);
+}
+
 G_DEFINE_TYPE(SPUse, sp_use, G_TYPE_OBJECT);
 
 static void