X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fsp-object.cpp;h=17def7f1554f1a13f6b68d5a2fcc8f6cbf7d3993;hb=42382dfb4164b919ffcdf03766da9f8be4e43b42;hp=f3e6d216415074fe85704e9e84c0f2ef7cebba5c;hpb=c87d0307348fcfdc65b6b4ab6999a3cb0de2431f;p=inkscape.git

diff --git a/src/sp-object.cpp b/src/sp-object.cpp
index f3e6d2164..17def7f15 100644
--- a/src/sp-object.cpp
+++ b/src/sp-object.cpp
@@ -1,12 +1,14 @@
-#define __SP_OBJECT_C__
 /** \file
  * SPObject implementation.
  *
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
+ *   Stephen Silver <sasilver@users.sourceforge.net>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
  *
- * Copyright (C) 1999-2005 authors
+ * Copyright (C) 1999-2008 authors
  * Copyright (C) 2001-2002 Ximian, Inc.
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
@@ -31,14 +33,19 @@
  * dictionary and so on. Source: doc/architecture.txt
  */
 
+#include <cstring>
+#include <string>
 
 #include "helper/sp-marshal.h"
 #include "xml/node-event-vector.h"
 #include "attributes.h"
+#include "color-profile-fns.h"
 #include "document.h"
 #include "style.h"
 #include "sp-object-repr.h"
 #include "sp-root.h"
+#include "sp-style-elem.h"
+#include "sp-script.h"
 #include "streq.h"
 #include "strneq.h"
 #include "xml/repr.h"
@@ -48,8 +55,8 @@
 #include "debug/demangle.h"
 #include "util/share.h"
 #include "util/format.h"
+#include "util/longest-common-suffix.h"
 
-#include "algorithms/longest-common-suffix.h"
 using std::memcpy;
 using std::strchr;
 using std::strcmp;
@@ -70,57 +77,60 @@ using std::strstr;
 # define debug(f, a...) /**/
 #endif
 
-static void sp_object_class_init(SPObjectClass *klass);
-static void sp_object_init(SPObject *object);
-static void sp_object_finalize(GObject *object);
-
-static void sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref);
-static void sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child);
-static void sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
-
-static void sp_object_release(SPObject *object);
-static void sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
-
-static void sp_object_private_set(SPObject *object, unsigned int key, gchar const *value);
-static Inkscape::XML::Node *sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
-
-/* Real handlers of repr signals */
-
-static void sp_object_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, gpointer data);
-
-static void sp_object_repr_content_changed(Inkscape::XML::Node *repr, gchar const *oldcontent, gchar const *newcontent, gpointer data);
-
-static void sp_object_repr_child_added(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data);
-static void sp_object_repr_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, void *data);
+guint update_in_progress = 0; // guard against update-during-update
 
-static void sp_object_repr_order_changed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *old, Inkscape::XML::Node *newer, gpointer data);
+Inkscape::XML::NodeEventVector object_event_vector = {
+    SPObject::sp_object_repr_child_added,
+    SPObject::sp_object_repr_child_removed,
+    SPObject::sp_object_repr_attr_changed,
+    SPObject::sp_object_repr_content_changed,
+    SPObject::sp_object_repr_order_changed
+};
 
-static gchar *sp_object_get_unique_id(SPObject *object, gchar const *defid);
+// A friend class used to set internal members on SPObject so as to not expose settors in SPObject's public API
+class SPObjectImpl
+{
+public:
 
-guint update_in_progress = 0; // guard against update-during-update
+/**
+ * Null's the id member of an SPObject without attempting to free prior contents.
+ */
+    static void setIdNull( SPObject* obj ) {
+        if (obj) {
+            obj->id = 0;
+        }
+    }
 
-Inkscape::XML::NodeEventVector object_event_vector = {
-    sp_object_repr_child_added,
-    sp_object_repr_child_removed,
-    sp_object_repr_attr_changed,
-    sp_object_repr_content_changed,
-    sp_object_repr_order_changed
+/**
+ * Sets the id member of an object, freeing any prior content.
+ */
+    static void setId( SPObject* obj, gchar const* id ) {
+        if (obj && (id != obj->id) ) {
+            if (obj->id) {
+                g_free(obj->id);
+                obj->id = 0;
+            }
+            if (id) {
+                obj->id = g_strdup(id);
+            }
+        }
+    }
 };
 
-static GObjectClass *parent_class;
+
+GObjectClass * SPObjectClass::static_parent_class = 0;
 
 /**
  * Registers the SPObject class with Gdk and returns its type number.
  */
-GType
-sp_object_get_type(void)
+GType SPObject::sp_object_get_type()
 {
     static GType type = 0;
     if (!type) {
         GTypeInfo info = {
             sizeof(SPObjectClass),
             NULL, NULL,
-            (GClassInitFunc) sp_object_class_init,
+            (GClassInitFunc) SPObjectClass::sp_object_class_init,
             NULL, NULL,
             sizeof(SPObject),
             16,
@@ -135,34 +145,32 @@ sp_object_get_type(void)
 /**
  * Initializes the SPObject vtable.
  */
-static void
-sp_object_class_init(SPObjectClass *klass)
+void SPObjectClass::sp_object_class_init(SPObjectClass *klass)
 {
     GObjectClass *object_class;
 
     object_class = (GObjectClass *) klass;
 
-    parent_class = (GObjectClass *) g_type_class_ref(G_TYPE_OBJECT);
+    static_parent_class = (GObjectClass *) g_type_class_ref(G_TYPE_OBJECT);
 
-    object_class->finalize = sp_object_finalize;
+    object_class->finalize = SPObject::sp_object_finalize;
 
-    klass->child_added = sp_object_child_added;
-    klass->remove_child = sp_object_remove_child;
-    klass->order_changed = sp_object_order_changed;
+    klass->child_added = SPObject::sp_object_child_added;
+    klass->remove_child = SPObject::sp_object_remove_child;
+    klass->order_changed = SPObject::sp_object_order_changed;
 
-    klass->release = sp_object_release;
+    klass->release = SPObject::sp_object_release;
 
-    klass->build = sp_object_build;
+    klass->build = SPObject::sp_object_build;
 
-    klass->set = sp_object_private_set;
-    klass->write = sp_object_private_write;
+    klass->set = SPObject::sp_object_private_set;
+    klass->write = SPObject::sp_object_private_write;
 }
 
 /**
  * Callback to initialize the SPObject object.
  */
-static void
-sp_object_init(SPObject *object)
+void SPObject::sp_object_init(SPObject *object)
 {
     debug("id=%x, typename=%s",object, g_type_name_from_instance((GTypeInstance*)object));
 
@@ -171,9 +179,11 @@ sp_object_init(SPObject *object)
     object->document = NULL;
     object->children = object->_last_child = NULL;
     object->parent = object->next = NULL;
-    object->repr = NULL;
-    object->id = NULL;
-    object->style = NULL;
+
+    //used XML Tree here.
+    Inkscape::XML::Node *repr = object->getRepr();
+    repr = NULL;
+    SPObjectImpl::setIdNull(object);
 
     object->_collection_policy = SPObject::COLLECT_WITH_PARENT;
 
@@ -183,6 +193,12 @@ sp_object_init(SPObject *object)
     new (&object->_position_changed_signal) sigc::signal<void, SPObject *>();
     object->_successor = NULL;
 
+    // FIXME: now we create style for all objects, but per SVG, only the following can have style attribute:
+    // vg, g, defs, desc, title, symbol, use, image, switch, path, rect, circle, ellipse, line, polyline,
+    // polygon, text, tspan, tref, textPath, altGlyph, glyphRef, marker, linearGradient, radialGradient,
+    // stop, pattern, clipPath, mask, filter, feImage, a, font, glyph, missing-glyph, foreignObject
+    object->style = sp_style_new_from_object(object);
+
     object->_label = NULL;
     object->_default_label = NULL;
 }
@@ -190,8 +206,7 @@ sp_object_init(SPObject *object)
 /**
  * Callback to destroy all members and connections of object and itself.
  */
-static void
-sp_object_finalize(GObject *object)
+void SPObject::sp_object_finalize(GObject *object)
 {
     SPObject *spobject = (SPObject *)object;
 
@@ -205,8 +220,8 @@ sp_object_finalize(GObject *object)
         spobject->_successor = NULL;
     }
 
-    if (((GObjectClass *) (parent_class))->finalize) {
-        (* ((GObjectClass *) (parent_class))->finalize)(object);
+    if (((GObjectClass *) (SPObjectClass::static_parent_class))->finalize) {
+        (* ((GObjectClass *) (SPObjectClass::static_parent_class))->finalize)(object);
     }
 
     spobject->_release_signal.~signal();
@@ -249,6 +264,19 @@ public:
 
 }
 
+gchar const* SPObject::getId() const {
+    return id;
+}
+
+Inkscape::XML::Node * SPObject::getRepr() {
+    return repr;
+}
+
+Inkscape::XML::Node const* SPObject::getRepr() const{
+    return repr;
+}
+
+
 /**
  * Increase reference count of object, with possible debugging.
  *
@@ -256,8 +284,7 @@ public:
  * \return object, NULL is error.
  * \pre object points to real object
  */
-SPObject *
-sp_object_ref(SPObject *object, SPObject *owner)
+SPObject *sp_object_ref(SPObject *object, SPObject *owner)
 {
     g_return_val_if_fail(object != NULL, NULL);
     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
@@ -276,8 +303,7 @@ sp_object_ref(SPObject *object, SPObject *owner)
  * \return always NULL
  * \pre object points to real object
  */
-SPObject *
-sp_object_unref(SPObject *object, SPObject *owner)
+SPObject *sp_object_unref(SPObject *object, SPObject *owner)
 {
     g_return_val_if_fail(object != NULL, NULL);
     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
@@ -298,8 +324,7 @@ sp_object_unref(SPObject *object, SPObject *owner)
  * \return object, NULL is error
  * \pre object points to real object
  */
-SPObject *
-sp_object_href(SPObject *object, gpointer owner)
+SPObject *sp_object_href(SPObject *object, gpointer /*owner*/)
 {
     g_return_val_if_fail(object != NULL, NULL);
     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
@@ -319,8 +344,7 @@ sp_object_href(SPObject *object, gpointer owner)
  * \return always NULL
  * \pre object points to real object and hrefcount>0
  */
-SPObject *
-sp_object_hunref(SPObject *object, gpointer owner)
+SPObject *sp_object_hunref(SPObject *object, gpointer /*owner*/)
 {
     g_return_val_if_fail(object != NULL, NULL);
     g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
@@ -335,10 +359,9 @@ sp_object_hunref(SPObject *object, gpointer owner)
 /**
  * Adds increment to _total_hrefcount of object and its parents.
  */
-void
-SPObject::_updateTotalHRefCount(int increment) {
+void SPObject::_updateTotalHRefCount(int increment) {
     SPObject *topmost_collectable = NULL;
-    for ( SPObject *iter = this ; iter ; iter = SP_OBJECT_PARENT(iter) ) {
+    for ( SPObject *iter = this ; iter ; iter = iter->parent ) {
         iter->_total_hrefcount += increment;
         if ( iter->_total_hrefcount < iter->hrefcount ) {
             g_critical("HRefs overcounted");
@@ -357,15 +380,14 @@ SPObject::_updateTotalHRefCount(int increment) {
 /**
  * True if object is non-NULL and this is some in/direct parent of object.
  */
-bool
-SPObject::isAncestorOf(SPObject const *object) const {
+bool SPObject::isAncestorOf(SPObject const *object) const {
     g_return_val_if_fail(object != NULL, false);
-    object = SP_OBJECT_PARENT(object);
+    object = object->parent;
     while (object) {
         if ( object == this ) {
             return true;
         }
-        object = SP_OBJECT_PARENT(object);
+        object = object->parent;
     }
     return false;
 }
@@ -381,8 +403,7 @@ bool same_objects(SPObject const &a, SPObject const &b) {
 /**
  * Returns youngest object being parent to this and object.
  */
-SPObject const *
-SPObject::nearestCommonAncestor(SPObject const *object) const {
+SPObject const *SPObject::nearestCommonAncestor(SPObject const *object) const {
     g_return_val_if_fail(object != NULL, NULL);
 
     using Inkscape::Algorithms::longest_common_suffix;
@@ -390,11 +411,15 @@ SPObject::nearestCommonAncestor(SPObject const *object) const {
 }
 
 SPObject const *AncestorSon(SPObject const *obj, SPObject const *ancestor) {
-    if (obj == NULL || ancestor == NULL)
-        return NULL;
-    if (SP_OBJECT_PARENT(obj) == ancestor)
-        return obj;
-    return AncestorSon(SP_OBJECT_PARENT(obj), ancestor);
+    SPObject const *result = 0;
+    if ( obj && ancestor ) {
+        if (obj->parent == ancestor) {
+            result = obj;
+        } else {
+            result = AncestorSon(obj->parent, ancestor);
+        }
+    }
+    return result;
 }
 
 /**
@@ -406,26 +431,29 @@ SPObject const *AncestorSon(SPObject const *obj, SPObject const *ancestor) {
  *    1    first object's position is greater than the second
  *   -1    first object's position is less than the second   \endverbatim
  */
-int
-sp_object_compare_position(SPObject const *first, SPObject const *second)
+int sp_object_compare_position(SPObject const *first, SPObject const *second)
 {
-    if (first == second) return 0;
-
-    SPObject const *ancestor = first->nearestCommonAncestor(second);
-    if (ancestor == NULL) return 0; // cannot compare, no common ancestor!
-
-    // we have an object and its ancestor (should not happen when sorting selection)
-    if (ancestor == first)
-        return 1;
-    if (ancestor == second)
-        return -1;
-
-    SPObject const *to_first = AncestorSon(first, ancestor);
-    SPObject const *to_second = AncestorSon(second, ancestor);
+    int result = 0;
+    if (first != second) {
+        SPObject const *ancestor = first->nearestCommonAncestor(second);
+        // Need a common ancestor to be able to compare
+        if ( ancestor ) {
+            // we have an object and its ancestor (should not happen when sorting selection)
+            if (ancestor == first) {
+                result = 1;
+            } else if (ancestor == second) {
+                result = -1;
+            } else {
+                SPObject const *to_first = AncestorSon(first, ancestor);
+                SPObject const *to_second = AncestorSon(second, ancestor);
 
-    g_assert(SP_OBJECT_PARENT(to_second) == SP_OBJECT_PARENT(to_first));
+                g_assert(to_second->parent == to_first->parent);
 
-    return sp_repr_compare_position(SP_OBJECT_REPR(to_first), SP_OBJECT_REPR(to_second));
+                result = sp_repr_compare_position(to_first->getRepr(), to_second->getRepr());
+            }
+        }
+    }
+    return result;
 }
 
 
@@ -433,26 +461,34 @@ sp_object_compare_position(SPObject const *first, SPObject const *second)
  * Append repr as child of this object.
  * \pre this is not a cloned object
  */
-SPObject *
-SPObject::appendChildRepr(Inkscape::XML::Node *repr) {
-    if (!SP_OBJECT_IS_CLONED(this)) {
-        SP_OBJECT_REPR(this)->appendChild(repr);
-        return SP_OBJECT_DOCUMENT(this)->getObjectByRepr(repr);
+SPObject *SPObject::appendChildRepr(Inkscape::XML::Node *repr) {
+    if ( !cloned ) {
+        getRepr()->appendChild(repr);
+        return document->getObjectByRepr(repr);
     } else {
         g_critical("Attempt to append repr as child of cloned object");
         return NULL;
     }
 }
 
-/**
- * Retrieves the children as a GSList object, optionally ref'ing the children
- * in the process, if add_ref is specified.
- */
+void SPObject::setCSS(SPCSSAttr *css, gchar const *attr)
+{
+    g_assert(this->getRepr() != NULL);
+    sp_repr_css_set(this->getRepr(), css, attr);
+}
+
+void SPObject::changeCSS(SPCSSAttr *css, gchar const *attr)
+{
+    g_assert(this->getRepr() != NULL);
+    sp_repr_css_change(this->getRepr(), css, attr);
+}
+
 GSList *SPObject::childList(bool add_ref, Action) {
     GSList *l = NULL;
-    for (SPObject *child = sp_object_first_child(this) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
-        if (add_ref)
+    for ( SPObject *child = firstChild() ; child; child = child->getNext() ) {
+        if (add_ref) {
             g_object_ref (G_OBJECT (child));
+        }
 
         l = g_slist_prepend (l, child);
     }
@@ -463,23 +499,20 @@ GSList *SPObject::childList(bool add_ref, Action) {
 /** Gets the label property for the object or a default if no label
  *  is defined.
  */
-gchar const *
-SPObject::label() const {
+gchar const *SPObject::label() const {
     return _label;
 }
 
 /** Returns a default label property for the object. */
-gchar const *
-SPObject::defaultLabel() const {
+gchar const *SPObject::defaultLabel() const {
     if (_label) {
         return _label;
     } else {
         if (!_default_label) {
-            gchar const *id=SP_OBJECT_ID(this);
-            if (id) {
-                _default_label = g_strdup_printf("#%s", id);
+            if (getId()) {
+                _default_label = g_strdup_printf("#%s", getId());
             } else {
-                _default_label = g_strdup_printf("<%s>", SP_OBJECT_REPR(this)->name());
+                _default_label = g_strdup_printf("<%s>", getRepr()->name());
             }
         }
         return _default_label;
@@ -487,35 +520,43 @@ SPObject::defaultLabel() const {
 }
 
 /** Sets the label property for the object */
-void
-SPObject::setLabel(gchar const *label) {
-    SP_OBJECT_REPR(this)->setAttribute("inkscape:label", label, false);
+void SPObject::setLabel(gchar const *label) {
+    getRepr()->setAttribute("inkscape:label", label, false);
 }
 
 
 /** Queues the object for orphan collection */
-void
-SPObject::requestOrphanCollection() {
+void SPObject::requestOrphanCollection() {
     g_return_if_fail(document != NULL);
-    document->queueForOrphanCollection(this);
-
-    /** \todo
-     * This is a temporary hack added to make fill&stroke rebuild its
-     * gradient list when the defs are vacuumed.  gradient-vector.cpp
-     * listens to the modified signal on defs, and now we give it that
-     * signal.  Mental says that this should be made automatic by
-     * merging SPObjectGroup with SPObject; SPObjectGroup would issue
-     * this signal automatically. Or maybe just derive SPDefs from
-     * SPObjectGroup?
-     */
 
-    this->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
+    // do not remove style or script elements (Bug #276244)
+    if (SP_IS_STYLE_ELEM(this)) {
+        // leave it
+    } else if (SP_IS_SCRIPT(this)) {
+        // leave it
+    } else if (SP_IS_PAINT_SERVER(this) && static_cast<SPPaintServer*>(this)->isSwatch() ) {
+        // leave it
+    } else if (IS_COLORPROFILE(this)) {
+        // leave it
+    } else {
+        document->queueForOrphanCollection(this);
+
+        /** \todo
+         * This is a temporary hack added to make fill&stroke rebuild its
+         * gradient list when the defs are vacuumed.  gradient-vector.cpp
+         * listens to the modified signal on defs, and now we give it that
+         * signal.  Mental says that this should be made automatic by
+         * merging SPObjectGroup with SPObject; SPObjectGroup would issue
+         * this signal automatically. Or maybe just derive SPDefs from
+         * SPObjectGroup?
+         */
+
+        this->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
+    }
 }
 
-/** Sends the delete signal to all children of this object recursively */
-void
-SPObject::_sendDeleteSignalRecursive() {
-    for (SPObject *child = sp_object_first_child(this); child; child = SP_OBJECT_NEXT(child)) {
+void SPObject::_sendDeleteSignalRecursive() {
+    for (SPObject *child = firstChild(); child; child = child->getNext()) {
         child->_delete_signal.emit(child);
         child->_sendDeleteSignalRecursive();
     }
@@ -528,8 +569,7 @@ SPObject::_sendDeleteSignalRecursive() {
  * signal.  If the \a propagate_descendants parameter is true, it
  * recursively sends the delete signal to children.
  */
-void
-SPObject::deleteObject(bool propagate, bool propagate_descendants)
+void SPObject::deleteObject(bool propagate, bool propagate_descendants)
 {
     sp_object_ref(this, NULL);
     if (propagate) {
@@ -539,7 +579,7 @@ SPObject::deleteObject(bool propagate, bool propagate_descendants)
         this->_sendDeleteSignalRecursive();
     }
 
-    Inkscape::XML::Node *repr=SP_OBJECT_REPR(this);
+    Inkscape::XML::Node *repr = getRepr();
     if (repr && sp_repr_parent(repr)) {
         sp_repr_unparent(repr);
     }
@@ -554,59 +594,57 @@ SPObject::deleteObject(bool propagate, bool propagate_descendants)
  * Put object into object tree, under parent, and behind prev;
  * also update object's XML space.
  */
-void
-sp_object_attach(SPObject *parent, SPObject *object, SPObject *prev)
+void SPObject::attach(SPObject *object, SPObject *prev)
 {
-    g_return_if_fail(parent != NULL);
-    g_return_if_fail(SP_IS_OBJECT(parent));
+    //g_return_if_fail(parent != NULL);
+    //g_return_if_fail(SP_IS_OBJECT(parent));
     g_return_if_fail(object != NULL);
     g_return_if_fail(SP_IS_OBJECT(object));
     g_return_if_fail(!prev || SP_IS_OBJECT(prev));
-    g_return_if_fail(!prev || prev->parent == parent);
+    g_return_if_fail(!prev || prev->parent == this);
     g_return_if_fail(!object->parent);
 
-    sp_object_ref(object, parent);
-    object->parent = parent;
-    parent->_updateTotalHRefCount(object->_total_hrefcount);
+    sp_object_ref(object, this);
+    object->parent = this;
+    this->_updateTotalHRefCount(object->_total_hrefcount);
 
     SPObject *next;
     if (prev) {
         next = prev->next;
         prev->next = object;
     } else {
-        next = parent->children;
-        parent->children = object;
+        next = this->children;
+        this->children = object;
     }
     object->next = next;
     if (!next) {
-        parent->_last_child = object;
+        this->_last_child = object;
     }
     if (!object->xml_space.set)
-        object->xml_space.value = parent->xml_space.value;
+        object->xml_space.value = this->xml_space.value;
 }
 
 /**
  * In list of object's siblings, move object behind prev.
  */
-void
-sp_object_reorder(SPObject *object, SPObject *prev) {
-    g_return_if_fail(object != NULL);
-    g_return_if_fail(SP_IS_OBJECT(object));
-    g_return_if_fail(object->parent != NULL);
-    g_return_if_fail(object != prev);
+void SPObject::reorder(SPObject *prev) {
+    //g_return_if_fail(object != NULL);
+    //g_return_if_fail(SP_IS_OBJECT(object));
+    g_return_if_fail(this->parent != NULL);
+    g_return_if_fail(this != prev);
     g_return_if_fail(!prev || SP_IS_OBJECT(prev));
-    g_return_if_fail(!prev || prev->parent == object->parent);
+    g_return_if_fail(!prev || prev->parent == this->parent);
 
-    SPObject *const parent=object->parent;
+    SPObject *const parent=this->parent;
 
     SPObject *old_prev=NULL;
-    for ( SPObject *child = parent->children ; child && child != object ;
+    for ( SPObject *child = parent->children ; child && child != this ;
           child = child->next )
     {
         old_prev = child;
     }
 
-    SPObject *next=object->next;
+    SPObject *next=this->next;
     if (old_prev) {
         old_prev->next = next;
     } else {
@@ -617,32 +655,31 @@ sp_object_reorder(SPObject *object, SPObject *prev) {
     }
     if (prev) {
         next = prev->next;
-        prev->next = object;
+        prev->next = this;
     } else {
         next = parent->children;
-        parent->children = object;
+        parent->children = this;
     }
-    object->next = next;
+    this->next = next;
     if (!next) {
-        parent->_last_child = object;
+        parent->_last_child = this;
     }
 }
 
 /**
  * Remove object from parent's children, release and unref it.
  */
-void
-sp_object_detach(SPObject *parent, SPObject *object) {
-    g_return_if_fail(parent != NULL);
-    g_return_if_fail(SP_IS_OBJECT(parent));
+void SPObject::detach(SPObject *object) {
+    //g_return_if_fail(parent != NULL);
+    //g_return_if_fail(SP_IS_OBJECT(parent));
     g_return_if_fail(object != NULL);
     g_return_if_fail(SP_IS_OBJECT(object));
-    g_return_if_fail(object->parent == parent);
+    g_return_if_fail(object->parent == this);
 
     object->releaseReferences();
 
     SPObject *prev=NULL;
-    for ( SPObject *child = parent->children ; child && child != object ;
+    for ( SPObject *child = this->children ; child && child != object ;
           child = child->next )
     {
         prev = child;
@@ -652,57 +689,56 @@ sp_object_detach(SPObject *parent, SPObject *object) {
     if (prev) {
         prev->next = next;
     } else {
-        parent->children = next;
+        this->children = next;
     }
     if (!next) {
-        parent->_last_child = prev;
+        this->_last_child = prev;
     }
 
     object->next = NULL;
     object->parent = NULL;
 
-    parent->_updateTotalHRefCount(-object->_total_hrefcount);
-    sp_object_unref(object, parent);
+    this->_updateTotalHRefCount(-object->_total_hrefcount);
+    sp_object_unref(object, this);
 }
 
 /**
  * Return object's child whose node pointer equals repr.
  */
-SPObject *
-sp_object_get_child_by_repr(SPObject *object, Inkscape::XML::Node *repr)
+SPObject *SPObject::get_child_by_repr(Inkscape::XML::Node *repr)
 {
-    g_return_val_if_fail(object != NULL, NULL);
-    g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
     g_return_val_if_fail(repr != NULL, NULL);
+    SPObject *result = 0;
 
-    if (object->_last_child && SP_OBJECT_REPR(object->_last_child) == repr)
-        return object->_last_child;   // optimization for common scenario
-    for ( SPObject *child = object->children ; child ; child = child->next ) {
-        if ( SP_OBJECT_REPR(child) == repr ) {
-            return child;
+    if ( _last_child && (_last_child->getRepr() == repr) ) {
+        result = _last_child;   // optimization for common scenario
+    } else {
+        for ( SPObject *child = children ; child ; child = child->next ) {
+            if ( child->getRepr() == repr ) {
+                result = child;
+                break;
+            }
         }
     }
-
-    return NULL;
+    return result;
 }
 
 /**
  * Callback for child_added event.
  * Invoked whenever the given mutation event happens in the XML tree.
  */
-static void
-sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
+void SPObject::sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
 {
     GType type = sp_repr_type_lookup(child);
     if (!type) {
         return;
     }
     SPObject *ochild = SP_OBJECT(g_object_new(type, 0));
-    SPObject *prev = ref ? sp_object_get_child_by_repr(object, ref) : NULL;
-    sp_object_attach(object, ochild, prev);
+    SPObject *prev = ref ? object->get_child_by_repr(ref) : NULL;
+    object->attach(ochild, prev);
     sp_object_unref(ochild, NULL);
 
-    sp_object_invoke_build(ochild, object->document, child, SP_OBJECT_IS_CLONED(object));
+    ochild->invoke_build(object->document, child, object->cloned);
 }
 
 /**
@@ -716,11 +752,11 @@ sp_object_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XM
  * SPRoot destroys the whole document tree.
  * \see sp_object_build()
  */
-static void sp_object_release(SPObject *object)
+void SPObject::sp_object_release(SPObject *object)
 {
     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
     while (object->children) {
-        sp_object_detach(object, object->children);
+        object->detach(object->children);
     }
 }
 
@@ -732,13 +768,14 @@ static void sp_object_release(SPObject *object)
  * tree, BEFORE removal from the XML tree happens, so grouping
  * objects can safely release the child data.
  */
-static void
-sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child)
+void SPObject::sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child)
 {
     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
-    SPObject *ochild = sp_object_get_child_by_repr(object, child);
-    g_return_if_fail(ochild != NULL);
-    sp_object_detach(object, ochild);
+    SPObject *ochild = object->get_child_by_repr(child);
+    g_return_if_fail (ochild != NULL || !strcmp("comment", child->name())); // comments have no objects
+    if (ochild) {
+        object->detach(ochild);
+    }
 }
 
 /**
@@ -747,13 +784,13 @@ sp_object_remove_child(SPObject *object, Inkscape::XML::Node *child)
  * Invoked whenever the given mutation event happens in the XML tree.
  * \param old_ref Ignored
  */
-static void sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref,
+void SPObject::sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node */*old_ref*/,
                                     Inkscape::XML::Node *new_ref)
 {
-    SPObject *ochild = sp_object_get_child_by_repr(object, child);
+    SPObject *ochild = object->get_child_by_repr(child);
     g_return_if_fail(ochild != NULL);
-    SPObject *prev = new_ref ? sp_object_get_child_by_repr(object, new_ref) : NULL;
-    sp_object_reorder(ochild, prev);
+    SPObject *prev = new_ref ? object->get_child_by_repr(new_ref) : NULL;
+    ochild->reorder(prev);
     ochild->_position_changed_signal.emit(ochild);
 }
 
@@ -768,15 +805,14 @@ static void sp_object_order_changed(SPObject *object, Inkscape::XML::Node *child
  * SPDocument does after the creation of the XML tree).
  * \see sp_object_release()
  */
-static void
-sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+void SPObject::sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
 {
     /* Nothing specific here */
     debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
 
-    sp_object_read_attr(object, "xml:space");
-    sp_object_read_attr(object, "inkscape:label");
-    sp_object_read_attr(object, "inkscape:collect");
+    object->readAttr("xml:space");
+    object->readAttr("inkscape:label");
+    object->readAttr("inkscape:collect");
 
     for (Inkscape::XML::Node *rchild = repr->firstChild() ; rchild != NULL; rchild = rchild->next()) {
         GType type = sp_repr_type_lookup(rchild);
@@ -784,65 +820,98 @@ sp_object_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *rep
             continue;
         }
         SPObject *child = SP_OBJECT(g_object_new(type, 0));
-        sp_object_attach(object, child, object->lastChild());
+        object->attach(child, object->lastChild());
         sp_object_unref(child, NULL);
-        sp_object_invoke_build(child, document, rchild, SP_OBJECT_IS_CLONED(object));
+        child->invoke_build(document, rchild, object->cloned);
     }
 }
 
-void
-sp_object_invoke_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr, unsigned int cloned)
+void SPObject::invoke_build(SPDocument *document, Inkscape::XML::Node *repr, unsigned int cloned)
 {
-    debug("id=%x, typename=%s", object, g_type_name_from_instance((GTypeInstance*)object));
+    debug("id=%x, typename=%s", this, g_type_name_from_instance((GTypeInstance*)this));
 
-    g_assert(object != NULL);
-    g_assert(SP_IS_OBJECT(object));
+    //g_assert(object != NULL);
+    //g_assert(SP_IS_OBJECT(object));
     g_assert(document != NULL);
     g_assert(repr != NULL);
 
-    g_assert(object->document == NULL);
-    g_assert(object->repr == NULL);
-    g_assert(object->id == NULL);
+    g_assert(this->document == NULL);
+    g_assert(this->repr == NULL);
+    g_assert(this->getId() == NULL);
 
     /* Bookkeeping */
 
-    object->document = document;
-    object->repr = repr;
-    Inkscape::GC::anchor(repr);
-    object->cloned = cloned;
-
-    if (!SP_OBJECT_IS_CLONED(object)) {
-        object->document->bindObjectToRepr(object->repr, object);
-
-        if (Inkscape::XML::id_permitted(object->repr)) {
-            /* If we are not cloned, force unique id */
-            gchar const *id = object->repr->attribute("id");
-            gchar *realid = sp_object_get_unique_id(object, id);
-            g_assert(realid != NULL);
-
-            object->document->bindObjectToId(realid, object);
-            object->id = realid;
-
-            /* Redefine ID, if required */
-            if ((id == NULL) || (strcmp(id, realid) != 0)) {
-                bool undo_sensitive=sp_document_get_undo_sensitive(document);
-                sp_document_set_undo_sensitive(document, FALSE);
-                object->repr->setAttribute("id", realid);
-                sp_document_set_undo_sensitive(document, undo_sensitive);
+    this->document = document;
+    this->repr = repr;
+    if (!cloned) {
+        Inkscape::GC::anchor(repr);
+    }
+    this->cloned = cloned;
+
+    if ( !cloned ) {
+        this->document->bindObjectToRepr(this->repr, this);
+
+        if (Inkscape::XML::id_permitted(this->repr)) {
+            /* If we are not cloned, and not seeking, force unique id */
+            gchar const *id = this->repr->attribute("id");
+            if (!document->isSeeking()) {
+                {
+                    gchar *realid = sp_object_get_unique_id(this, id);
+                    g_assert(realid != NULL);
+
+                    this->document->bindObjectToId(realid, this);
+                    SPObjectImpl::setId(this, realid);
+                    g_free(realid);
+                }
+
+                /* Redefine ID, if required */
+                if ((id == NULL) || (strcmp(id, this->getId()) != 0)) {
+                    this->repr->setAttribute("id", this->getId());
+                }
+            } else if (id) {
+                // bind if id, but no conflict -- otherwise, we can expect
+                // a subsequent setting of the id attribute
+                if (!this->document->getObjectById(id)) {
+                    this->document->bindObjectToId(id, this);
+                    SPObjectImpl::setId(this, id);
+                }
             }
         }
     } else {
-        g_assert(object->id == NULL);
+        g_assert(this->getId() == NULL);
     }
 
     /* Invoke derived methods, if any */
-
-    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->build) {
-        (*((SPObjectClass *) G_OBJECT_GET_CLASS(object))->build)(object, document, repr);
+    if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->build) {
+        (*((SPObjectClass *) G_OBJECT_GET_CLASS(this))->build)(this, document, repr);
     }
 
     /* Signalling (should be connected AFTER processing derived methods */
-    sp_repr_add_listener(repr, &object_event_vector, object);
+    sp_repr_add_listener(repr, &object_event_vector, this);
+}
+
+long long int SPObject::getIntAttribute(char const *key, long long int def)
+{
+    return sp_repr_get_int_attribute(getRepr(),key,def);
+}
+
+unsigned SPObject::getPosition(){
+    g_assert(this->repr);
+
+    return repr->position();
+}
+
+void SPObject::appendChild(Inkscape::XML::Node *child) {
+    g_assert(this->repr);
+
+    repr->appendChild(child);
+}
+
+void SPObject::addChild(Inkscape::XML::Node *child, Inkscape::XML::Node * prev)
+{
+    g_assert(this->repr);
+
+    repr->addChild(child,prev);
 }
 
 void SPObject::releaseReferences() {
@@ -851,16 +920,16 @@ void SPObject::releaseReferences() {
 
     sp_repr_remove_listener_by_data(this->repr, this);
 
+    this->_release_signal.emit(this);
     SPObjectClass *klass=(SPObjectClass *)G_OBJECT_GET_CLASS(this);
     if (klass->release) {
         klass->release(this);
     }
-    this->_release_signal.emit(this);
 
     /* all hrefs should be released by the "release" handlers */
     g_assert(this->hrefcount == 0);
 
-    if (!SP_OBJECT_IS_CLONED(this)) {
+    if (!cloned) {
         if (this->id) {
             this->document->bindObjectToId(this->id, NULL);
         }
@@ -871,6 +940,8 @@ void SPObject::releaseReferences() {
         this->_default_label = NULL;
 
         this->document->bindObjectToRepr(this->repr, NULL);
+
+        Inkscape::GC::release(this->repr);
     } else {
         g_assert(!this->id);
     }
@@ -879,29 +950,38 @@ void SPObject::releaseReferences() {
         this->style = sp_style_unref(this->style);
     }
 
-    Inkscape::GC::release(this->repr);
-
     this->document = NULL;
     this->repr = NULL;
 }
 
+
+SPObject *SPObject::getPrev()
+{
+    SPObject *prev = 0;
+    for ( SPObject *obj = parent->firstChild(); obj && !prev; obj = obj->getNext() ) {
+        if (obj->getNext() == this) {
+            prev = obj;
+        }
+    }
+    return prev;
+}
+
 /**
  * Callback for child_added node event.
  */
-static void
-sp_object_repr_child_added(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data)
+void SPObject::sp_object_repr_child_added(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data)
 {
     SPObject *object = SP_OBJECT(data);
 
-    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->child_added)
+    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->child_added) {
         (*((SPObjectClass *)G_OBJECT_GET_CLASS(object))->child_added)(object, child, ref);
+    }
 }
 
 /**
  * Callback for remove_child node event.
  */
-static void
-sp_object_repr_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data)
+void SPObject::sp_object_repr_child_removed(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node *child, Inkscape::XML::Node */*ref*/, gpointer data)
 {
     SPObject *object = SP_OBJECT(data);
 
@@ -915,8 +995,7 @@ sp_object_repr_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *chi
  *
  * \todo fixme:
  */
-static void
-sp_object_repr_order_changed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node *old, Inkscape::XML::Node *newer, gpointer data)
+void SPObject::sp_object_repr_order_changed(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node *child, Inkscape::XML::Node *old, Inkscape::XML::Node *newer, gpointer data)
 {
     SPObject *object = SP_OBJECT(data);
 
@@ -928,39 +1007,45 @@ sp_object_repr_order_changed(Inkscape::XML::Node *repr, Inkscape::XML::Node *chi
 /**
  * Callback for set event.
  */
-static void
-sp_object_private_set(SPObject *object, unsigned int key, gchar const *value)
+void SPObject::sp_object_private_set(SPObject *object, unsigned int key, gchar const *value)
 {
     g_assert(key != SP_ATTR_INVALID);
 
     switch (key) {
         case SP_ATTR_ID:
-            if ( !SP_OBJECT_IS_CLONED(object) && object->repr->type() == Inkscape::XML::ELEMENT_NODE ) {
+
+            //XML Tree being used here.
+            if ( !object->cloned && object->getRepr()->type() == Inkscape::XML::ELEMENT_NODE ) {
                 SPDocument *document=object->document;
                 SPObject *conflict=NULL;
 
-                if (value) {
-                    conflict = document->getObjectById((char const *)value);
+                gchar const *new_id = value;
+
+                if (new_id) {
+                    conflict = document->getObjectById((char const *)new_id);
                 }
+
                 if ( conflict && conflict != object ) {
-                    sp_object_ref(conflict, NULL);
-                    // give the conflicting object a new ID
-                    gchar *new_conflict_id = sp_object_get_unique_id(conflict, NULL);
-                    SP_OBJECT_REPR(conflict)->setAttribute("id", new_conflict_id);
-                    g_free(new_conflict_id);
-                    sp_object_unref(conflict, NULL);
+                    if (!document->isSeeking()) {
+                        sp_object_ref(conflict, NULL);
+                        // give the conflicting object a new ID
+                        gchar *new_conflict_id = sp_object_get_unique_id(conflict, NULL);
+                        conflict->getRepr()->setAttribute("id", new_conflict_id);
+                        g_free(new_conflict_id);
+                        sp_object_unref(conflict, NULL);
+                    } else {
+                        new_id = NULL;
+                    }
                 }
 
-                if (object->id) {
-                    document->bindObjectToId(object->id, NULL);
-                    g_free(object->id);
+                if (object->getId()) {
+                    document->bindObjectToId(object->getId(), NULL);
+                    SPObjectImpl::setId(object, 0);
                 }
 
-                if (value) {
-                    object->id = g_strdup((char const*)value);
-                    document->bindObjectToId(object->id, object);
-                } else {
-                    object->id = NULL;
+                if (new_id) {
+                    SPObjectImpl::setId(object, new_id);
+                    document->bindObjectToId(object->getId(), object);
                 }
 
                 g_free(object->_default_label);
@@ -998,6 +1083,10 @@ sp_object_private_set(SPObject *object, unsigned int key, gchar const *value)
             }
             object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
             break;
+        case SP_ATTR_STYLE:
+            sp_style_read_from_object(object->style, object);
+            object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+            break;
         default:
             break;
     }
@@ -1006,65 +1095,63 @@ sp_object_private_set(SPObject *object, unsigned int key, gchar const *value)
 /**
  * Call virtual set() function of object.
  */
-void
-sp_object_set(SPObject *object, unsigned int key, gchar const *value)
+void SPObject::setKeyValue(unsigned int key, gchar const *value)
 {
-    g_assert(object != NULL);
-    g_assert(SP_IS_OBJECT(object));
+    //g_assert(object != NULL);
+    //g_assert(SP_IS_OBJECT(object));
 
-    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->set) {
-        ((SPObjectClass *) G_OBJECT_GET_CLASS(object))->set(object, key, value);
+    if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->set) {
+        ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->set(this, key, value);
     }
 }
 
 /**
  * Read value of key attribute from XML node into object.
  */
-void
-sp_object_read_attr(SPObject *object, gchar const *key)
+void SPObject::readAttr(gchar const *key)
 {
-    g_assert(object != NULL);
-    g_assert(SP_IS_OBJECT(object));
+    //g_assert(object != NULL);
+    //g_assert(SP_IS_OBJECT(object));
     g_assert(key != NULL);
 
-    g_assert(object->repr != NULL);
+    //XML Tree being used here.
+    g_assert(this->getRepr() != NULL);
 
     unsigned int keyid = sp_attribute_lookup(key);
     if (keyid != SP_ATTR_INVALID) {
         /* Retrieve the 'key' attribute from the object's XML representation */
-        gchar const *value = object->repr->attribute(key);
+        gchar const *value = getRepr()->attribute(key);
 
-        sp_object_set(object, keyid, value);
+        setKeyValue(keyid, value);
     }
 }
 
 /**
  * Callback for attr_changed node event.
  */
-static void
-sp_object_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, gpointer data)
+void SPObject::sp_object_repr_attr_changed(Inkscape::XML::Node */*repr*/, gchar const *key, gchar const */*oldval*/, gchar const */*newval*/, bool is_interactive, gpointer data)
 {
     SPObject *object = SP_OBJECT(data);
 
-    sp_object_read_attr(object, key);
+    object->readAttr(key);
 
     // manual changes to extension attributes require the normal
     // attributes, which depend on them, to be updated immediately
     if (is_interactive) {
-        object->updateRepr(repr, 0);
+        object->updateRepr(0);
     }
 }
 
 /**
  * Callback for content_changed node event.
  */
-static void
-sp_object_repr_content_changed(Inkscape::XML::Node *repr, gchar const *oldcontent, gchar const *newcontent, gpointer data)
+void SPObject::sp_object_repr_content_changed(Inkscape::XML::Node */*repr*/, gchar const */*oldcontent*/, gchar const */*newcontent*/, gpointer data)
 {
     SPObject *object = SP_OBJECT(data);
 
-    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->read_content)
+    if (((SPObjectClass *) G_OBJECT_GET_CLASS(object))->read_content) {
         (*((SPObjectClass *) G_OBJECT_GET_CLASS(object))->read_content)(object);
+    }
 }
 
 /**
@@ -1086,16 +1173,15 @@ sp_xml_get_space_string(unsigned int space)
 /**
  * Callback for write event.
  */
-static Inkscape::XML::Node *
-sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+Inkscape::XML::Node * SPObject::sp_object_private_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags)
 {
     if (!repr && (flags & SP_OBJECT_WRITE_BUILD)) {
-        repr = SP_OBJECT_REPR(object)->duplicate();
+        repr = object->getRepr()->duplicate(doc);
         if (!( flags & SP_OBJECT_WRITE_EXT )) {
             repr->setAttribute("inkscape:collect", NULL);
         }
     } else {
-        repr->setAttribute("id", object->id);
+        repr->setAttribute("id", object->getId());
 
         if (object->xml_space.set) {
             char const *xml_space;
@@ -1110,6 +1196,38 @@ sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
         } else {
             repr->setAttribute("inkscape:collect", NULL);
         }
+
+        SPStyle const *const obj_style = object->style;
+        if (obj_style) {
+            gchar *s = sp_style_write_string(obj_style, SP_STYLE_FLAG_IFSET);
+            repr->setAttribute("style", ( *s ? s : NULL ));
+            g_free(s);
+        } else {
+            /** \todo I'm not sure what to do in this case.  Bug #1165868
+             * suggests that it can arise, but the submitter doesn't know
+             * how to do so reliably.  The main two options are either
+             * leave repr's style attribute unchanged, or explicitly clear it.
+             * Must also consider what to do with property attributes for
+             * the element; see below.
+             */
+            char const *style_str = repr->attribute("style");
+            if (!style_str) {
+                style_str = "NULL";
+            }
+            g_warning("Item's style is NULL; repr style attribute is %s", style_str);
+        }
+
+        /** \note We treat object->style as authoritative.  Its effects have
+         * been written to the style attribute above; any properties that are
+         * unset we take to be deliberately unset (e.g. so that clones can
+         * override the property).
+         *
+         * Note that the below has an undesirable consequence of changing the
+         * appearance on renderers that lack CSS support (e.g. SVG tiny);
+         * possibly we should write property attributes instead of a style
+         * attribute.
+         */
+        sp_style_unset_property_attrs (object);
     }
 
     return repr;
@@ -1118,12 +1236,11 @@ sp_object_private_write(SPObject *object, Inkscape::XML::Node *repr, guint flags
 /**
  * Update this object's XML node with flags value.
  */
-Inkscape::XML::Node *
-SPObject::updateRepr(unsigned int flags) {
-    if (!SP_OBJECT_IS_CLONED(this)) {
-        Inkscape::XML::Node *repr=SP_OBJECT_REPR(this);
+Inkscape::XML::Node * SPObject::updateRepr(unsigned int flags) {
+    if ( !cloned ) {
+        Inkscape::XML::Node *repr = getRepr();
         if (repr) {
-            return updateRepr(repr, flags);
+            return updateRepr(repr->document(), repr, flags);
         } else {
             g_critical("Attempt to update non-existent repr");
             return NULL;
@@ -1134,26 +1251,31 @@ SPObject::updateRepr(unsigned int flags) {
     }
 }
 
-Inkscape::XML::Node *
-SPObject::updateRepr(Inkscape::XML::Node *repr, unsigned int flags) {
-    if (SP_OBJECT_IS_CLONED(this)) {
+/** Used both to create reprs in the original document, and to create
+ *  reprs in another document (e.g. a temporary document used when
+ *  saving as "Plain SVG"
+ */
+Inkscape::XML::Node * SPObject::updateRepr(Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, unsigned int flags) {
+    g_assert(doc != NULL);
+
+    if (cloned) {
         /* cloned objects have no repr */
         return NULL;
     }
     if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->write) {
         if (!(flags & SP_OBJECT_WRITE_BUILD) && !repr) {
-            repr = SP_OBJECT_REPR(this);
+            repr = getRepr();
         }
-        return ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->write(this, repr, flags);
+        return ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->write(this, doc, repr, flags);
     } else {
         g_warning("Class %s does not implement ::write", G_OBJECT_TYPE_NAME(this));
         if (!repr) {
             if (flags & SP_OBJECT_WRITE_BUILD) {
-                repr = SP_OBJECT_REPR(this)->duplicate();
+                repr = getRepr()->duplicate(doc);
             }
-            /// \todo fixme: else probably error (Lauris) */
+            /// \todo FIXME: else probably error (Lauris) */
         } else {
-            repr->mergeFrom(SP_OBJECT_REPR(this), "id");
+            repr->mergeFrom(getRepr(), "id");
         }
         return repr;
     }
@@ -1166,8 +1288,7 @@ SPObject::updateRepr(Inkscape::XML::Node *repr, unsigned int flags) {
  * recursively add CHILD_MODIFIED flag to
  * parent and ancestors (as far up as necessary).
  */
-void
-SPObject::requestDisplayUpdate(unsigned int flags)
+void SPObject::requestDisplayUpdate(unsigned int flags)
 {
     g_return_if_fail( this->document != NULL );
 
@@ -1189,24 +1310,25 @@ SPObject::requestDisplayUpdate(unsigned int flags)
      * don't need to set CHILD_MODIFIED on our ancestors because it's already been done.
      */
     if (already_propagated) {
-        SPObject *parent = SP_OBJECT_PARENT(this);
         if (parent) {
             parent->requestDisplayUpdate(SP_OBJECT_CHILD_MODIFIED_FLAG);
         } else {
-            sp_document_request_modified(SP_OBJECT_DOCUMENT(this));
+            document->requestModified();
         }
     }
 }
 
-void
-SPObject::updateDisplay(SPCtx *ctx, unsigned int flags)
+/**
+ * Update views
+ */
+void SPObject::updateDisplay(SPCtx *ctx, unsigned int flags)
 {
     g_return_if_fail(!(flags & ~SP_OBJECT_MODIFIED_CASCADE));
 
     update_in_progress ++;
 
 #ifdef SP_OBJECT_DEBUG_CASCADE
-    g_print("Update %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), SP_OBJECT_ID(this), flags, this->uflags, this->mflags);
+    g_print("Update %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), getId(), flags, this->uflags, this->mflags);
 #endif
 
     /* Get this flags */
@@ -1228,19 +1350,31 @@ SPObject::updateDisplay(SPCtx *ctx, unsigned int flags)
         }
     }
 
-    if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update)
-        ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update(this, ctx, flags);
+    try
+    {
+        if (((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update) {
+            ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update(this, ctx, flags);
+        }
+    }
+    catch(...)
+    {
+        /** \todo
+        * in case of catching an exception we need to inform the user somehow that the document is corrupted
+        * maybe by implementing an document flag documentOk
+        * or by a modal error dialog
+        */
+        g_warning("SPObject::updateDisplay(SPCtx *ctx, unsigned int flags) : throw in ((SPObjectClass *) G_OBJECT_GET_CLASS(this))->update(this, ctx, flags);");
+    }
 
     update_in_progress --;
 }
 
 /**
- * Request modified always bubbles *up* the tree, as opposed to 
- * request display update, which trickles down and relies on the 
+ * Request modified always bubbles *up* the tree, as opposed to
+ * request display update, which trickles down and relies on the
  * flags set during this pass...
  */
-void
-SPObject::requestModified(unsigned int flags)
+void SPObject::requestModified(unsigned int flags)
 {
     g_return_if_fail( this->document != NULL );
 
@@ -1258,26 +1392,27 @@ SPObject::requestModified(unsigned int flags)
      * don't need to set CHILD_MODIFIED on our ancestors because it's already been done.
      */
     if (already_propagated) {
-        SPObject *parent=SP_OBJECT_PARENT(this);
         if (parent) {
             parent->requestModified(SP_OBJECT_CHILD_MODIFIED_FLAG);
         } else {
-            sp_document_request_modified(SP_OBJECT_DOCUMENT(this));
+            document->requestModified();
         }
     }
 }
 
-/** 
- * This is what actually delivers the modified signals
+/**
+ *  Emits the MODIFIED signal with the object's flags.
+ *  The object's mflags are the original set aside during the update pass for
+ *  later delivery here.  Once emitModified() is called, those flags don't
+ *  need to be stored any longer.
  */
-void
-SPObject::emitModified(unsigned int flags)
+void SPObject::emitModified(unsigned int flags)
 {
     /* only the MODIFIED_CASCADE flag is legal here */
     g_return_if_fail(!(flags & ~SP_OBJECT_MODIFIED_CASCADE));
 
 #ifdef SP_OBJECT_DEBUG_CASCADE
-    g_print("Modified %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), SP_OBJECT_ID(this), flags, this->uflags, this->mflags);
+    g_print("Modified %s:%s %x %x %x\n", g_type_name_from_instance((GTypeInstance *) this), getId(), flags, this->uflags, this->mflags);
 #endif
 
     flags |= this->mflags;
@@ -1295,88 +1430,62 @@ SPObject::emitModified(unsigned int flags)
     g_object_unref(G_OBJECT(this));
 }
 
-/*
- * Get and set descriptive parameters
- *
- * These are inefficent, so they are not intended to be used interactively
- */
-
-gchar const *
-sp_object_title_get(SPObject *object)
-{
-    return NULL;
-}
-
-gchar const *
-sp_object_description_get(SPObject *object)
-{
-    return NULL;
-}
-
-unsigned int
-sp_object_title_set(SPObject *object, gchar const *title)
-{
-    return FALSE;
-}
-
-unsigned int
-sp_object_description_set(SPObject *object, gchar const *desc)
-{
-    return FALSE;
-}
-
-gchar const *
-sp_object_tagName_get(SPObject const *object, SPException *ex)
+gchar const *SPObject::getTagName(SPException *ex) const
 {
+    g_assert(repr != NULL);
     /* If exception is not clear, return */
     if (!SP_EXCEPTION_IS_OK(ex)) {
         return NULL;
     }
 
     /// \todo fixme: Exception if object is NULL? */
-    return object->repr->name();
+    //XML Tree being used here.
+    return getRepr()->name();
 }
 
-gchar const *
-sp_object_getAttribute(SPObject const *object, gchar const *key, SPException *ex)
+gchar const *SPObject::getAttribute(gchar const *key, SPException *ex) const
 {
+    g_assert(this->repr != NULL);
     /* If exception is not clear, return */
     if (!SP_EXCEPTION_IS_OK(ex)) {
         return NULL;
     }
 
     /// \todo fixme: Exception if object is NULL? */
-    return (gchar const *) object->repr->attribute(key);
+    //XML Tree being used here.
+    return (gchar const *) getRepr()->attribute(key);
 }
 
-void
-sp_object_setAttribute(SPObject *object, gchar const *key, gchar const *value, SPException *ex)
+void SPObject::setAttribute(gchar const *key, gchar const *value, SPException *ex)
 {
+    g_assert(this->repr != NULL);
     /* If exception is not clear, return */
     g_return_if_fail(SP_EXCEPTION_IS_OK(ex));
 
     /// \todo fixme: Exception if object is NULL? */
-    if (!sp_repr_set_attr(object->repr, key, value)) {
-        ex->code = SP_NO_MODIFICATION_ALLOWED_ERR;
-    }
+    //XML Tree being used here.
+    getRepr()->setAttribute(key, value, false);
 }
 
-void
-sp_object_removeAttribute(SPObject *object, gchar const *key, SPException *ex)
+void SPObject::removeAttribute(gchar const *key, SPException *ex)
 {
     /* If exception is not clear, return */
     g_return_if_fail(SP_EXCEPTION_IS_OK(ex));
 
     /// \todo fixme: Exception if object is NULL? */
-    if (!sp_repr_set_attr(object->repr, key, NULL)) {
-        ex->code = SP_NO_MODIFICATION_ALLOWED_ERR;
-    }
+    //XML Tree being used here.
+    getRepr()->setAttribute(key, NULL, false);
+}
+
+bool SPObject::storeAsDouble( gchar const *key, double *val ) const
+{
+    g_assert(this->getRepr()!= NULL);
+    return sp_repr_get_double(((Inkscape::XML::Node *)(this->getRepr())),key,val);
 }
 
 /* Helper */
 
-static gchar *
-sp_object_get_unique_id(SPObject *object, gchar const *id)
+gchar * SPObject::sp_object_get_unique_id(SPObject *object, gchar const *id)
 {
     static unsigned long count = 0;
 
@@ -1384,7 +1493,8 @@ sp_object_get_unique_id(SPObject *object, gchar const *id)
 
     count++;
 
-    gchar const *name = object->repr->name();
+    //XML Tree being used here.
+    gchar const *name = object->getRepr()->name();
     g_assert(name != NULL);
 
     gchar const *local = strchr(name, ':');
@@ -1441,14 +1551,14 @@ sp_object_get_unique_id(SPObject *object, gchar const *id)
  * <use> element instead), we should probably make the caller
  * responsible for ascending the repr tree as necessary.
  */
-gchar const *
-sp_object_get_style_property(SPObject const *object, gchar const *key, gchar const *def)
+gchar const * SPObject::getStyleProperty(gchar const *key, gchar const *def) const
 {
-    g_return_val_if_fail(object != NULL, NULL);
-    g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
+    //g_return_val_if_fail(object != NULL, NULL);
+    //g_return_val_if_fail(SP_IS_OBJECT(object), NULL);
     g_return_val_if_fail(key != NULL, NULL);
 
-    gchar const *style = object->repr->attribute("style");
+    //XML Tree being used here.
+    gchar const *style = getRepr()->attribute("style");
     if (style) {
         size_t const len = strlen(key);
         char const *p;
@@ -1456,9 +1566,15 @@ sp_object_get_style_property(SPObject const *object, gchar const *key, gchar con
                 != NULL )
         {
             p += len;
-            while ((*p <= ' ') && *p) p++;
-            if (*p++ != ':') break;
-            while ((*p <= ' ') && *p) p++;
+            while ((*p <= ' ') && *p) {
+                p++;
+            }
+            if (*p++ != ':') {
+                break;
+            }
+            while ((*p <= ' ') && *p) {
+                p++;
+            }
             size_t const inherit_len = sizeof("inherit") - 1;
             if (*p
                 && !(strneq(p, "inherit", inherit_len)
@@ -1469,12 +1585,14 @@ sp_object_get_style_property(SPObject const *object, gchar const *key, gchar con
             }
         }
     }
-    gchar const *val = object->repr->attribute(key);
+
+    //XML Tree being used here.
+    gchar const *val = getRepr()->attribute(key);
     if (val && !streq(val, "inherit")) {
         return val;
     }
-    if (object->parent) {
-        return sp_object_get_style_property(object->parent, key, def);
+    if (this->parent) {
+        return (this->parent)->getStyleProperty(key, def);
     }
 
     return def;
@@ -1483,8 +1601,7 @@ sp_object_get_style_property(SPObject const *object, gchar const *key, gchar con
 /**
  * Lifts SVG version of all root objects to version.
  */
-void
-SPObject::_requireSVGVersion(Inkscape::Version version) {
+void SPObject::_requireSVGVersion(Inkscape::Version version) {
     for ( SPObject::ParentIterator iter=this ; iter ; ++iter ) {
         SPObject *object=iter;
         if (SP_IS_ROOT(object)) {
@@ -1496,38 +1613,202 @@ SPObject::_requireSVGVersion(Inkscape::Version version) {
     }
 }
 
+/* Titles and descriptions */
+
+/* Note:
+   Titles and descriptions are stored in 'title' and 'desc' child elements
+   (see section 5.4 of the SVG 1.0 and 1.1 specifications).  The spec allows
+   an element to have more than one 'title' child element, but strongly
+   recommends against this and requires using the first one if a choice must
+   be made.  The same applies to 'desc' elements.  Therefore, these functions
+   ignore all but the first 'title' child element and first 'desc' child
+   element, except when deleting a title or description.
+*/
+
+/**
+ * Returns the title of this object, or NULL if there is none.
+ * The caller must free the returned string using g_free() - see comment
+ * for getTitleOrDesc() below.
+ */
+gchar * SPObject::title() const
+{
+    return getTitleOrDesc("svg:title");
+}
+
+/**
+ * Sets the title of this object
+ * A NULL first argument is interpreted as meaning that the existing title
+ * (if any) should be deleted.
+ * The second argument is optional - see setTitleOrDesc() below for details.
+ */
+bool SPObject::setTitle(gchar const *title, bool verbatim)
+{
+    return setTitleOrDesc(title, "svg:title", verbatim);
+}
+
+/**
+ * Returns the description of this object, or NULL if there is none.
+ * The caller must free the returned string using g_free() - see comment
+ * for getTitleOrDesc() below.
+ */
+gchar * SPObject::desc() const
+{
+    return getTitleOrDesc("svg:desc");
+}
+
+/**
+ * Sets the description of this object.
+ * A NULL first argument is interpreted as meaning that the existing
+ * description (if any) should be deleted.
+ * The second argument is optional - see setTitleOrDesc() below for details.
+ */
+bool SPObject::setDesc(gchar const *desc, bool verbatim)
+{
+    return setTitleOrDesc(desc, "svg:desc", verbatim);
+}
+
+/**
+ * Returns the title or description of this object, or NULL if there is none.
+ *
+ * The SVG spec allows 'title' and 'desc' elements to contain text marked up
+ * using elements from other namespaces.  Therefore, this function cannot
+ * in general just return a pointer to an existing string - it must instead
+ * construct a string containing the title or description without the mark-up.
+ * Consequently, the return value is a newly allocated string (or NULL), and
+ * must be freed (using g_free()) by the caller.
+ */
+gchar * SPObject::getTitleOrDesc(gchar const *svg_tagname) const
+{
+    gchar *result = 0;
+    SPObject *elem = findFirstChild(svg_tagname);
+    if ( elem ) {
+        result = g_string_free(elem->textualContent(), FALSE);
+    }
+    return result;
+}
+
 /**
- * Return sodipodi version of first root ancestor or (0,0).
+ * Sets or deletes the title or description of this object.
+ * A NULL 'value' argument causes the title or description to be deleted.
+ *
+ * 'verbatim' parameter:
+ * If verbatim==true, then the title or description is set to exactly the
+ * specified value.  If verbatim==false then two exceptions are made:
+ *   (1) If the specified value is just whitespace, then the title/description
+ *       is deleted.
+ *   (2) If the specified value is the same as the current value except for
+ *       mark-up, then the current value is left unchanged.
+ * This is usually the desired behaviour, so 'verbatim' defaults to false for
+ * setTitle() and setDesc().
+ *
+ * The return value is true if a change was made to the title/description,
+ * and usually false otherwise.
  */
-Inkscape::Version
-sp_object_get_sodipodi_version(SPObject *object)
+bool SPObject::setTitleOrDesc(gchar const *value, gchar const *svg_tagname, bool verbatim)
 {
-    static Inkscape::Version const zero_version(0, 0);
+    if (!verbatim) {
+        // If the new title/description is just whitespace,
+        // treat it as though it were NULL.
+        if (value) {
+            bool just_whitespace = true;
+            for (const gchar *cp = value; *cp; ++cp) {
+                if (!std::strchr("\r\n \t", *cp)) {
+                    just_whitespace = false;
+                    break;
+                }
+            }
+            if (just_whitespace) {
+                value = NULL;
+            }
+        }
+        // Don't stomp on mark-up if there is no real change.
+        if (value) {
+            gchar *current_value = getTitleOrDesc(svg_tagname);
+            if (current_value) {
+                bool different = std::strcmp(current_value, value);
+                g_free(current_value);
+                if (!different) {
+                    return false;
+                }
+            }
+        }
+    }
 
-    while (object) {
-        if (SP_IS_ROOT(object)) {
-            return SP_ROOT(object)->version.sodipodi;
+    SPObject *elem = findFirstChild(svg_tagname);
+
+    if (value == NULL) {
+        if (elem == NULL) {
+            return false;
+        }
+        // delete the title/description(s)
+        while (elem) {
+            elem->deleteObject();
+            elem = findFirstChild(svg_tagname);
         }
-        object = SP_OBJECT_PARENT(object);
+        return true;
+    }
+
+    Inkscape::XML::Document *xml_doc = document->getReprDoc();
+
+    if (elem == NULL) {
+        // create a new 'title' or 'desc' element, putting it at the
+        // beginning (in accordance with the spec's recommendations)
+        Inkscape::XML::Node *xml_elem = xml_doc->createElement(svg_tagname);
+        repr->addChild(xml_elem, NULL);
+        elem = document->getObjectByRepr(xml_elem);
+        Inkscape::GC::release(xml_elem);
+    }
+    else {
+        // remove the current content of the 'text' or 'desc' element
+        SPObject *child;
+        while (NULL != (child = elem->firstChild())) child->deleteObject();
     }
 
-    return zero_version;
+    // add the new content
+    elem->appendChildRepr(xml_doc->createTextNode(value));
+    return true;
 }
 
 /**
- * Returns previous object in sibling list or NULL.
+ * Find the first child of this object with a given tag name,
+ * and return it.  Returns NULL if there is no matching child.
  */
-SPObject *
-sp_object_prev(SPObject *child)
+SPObject * SPObject::findFirstChild(gchar const *tagname) const
 {
-    SPObject *parent = SP_OBJECT_PARENT(child);
-    for ( SPObject *i = sp_object_first_child(parent); i; i = SP_OBJECT_NEXT(i) ) {
-        if (SP_OBJECT_NEXT(i) == child)
-            return i;
+    for (SPObject *child = children; child; child = child->next)
+    {
+        if (child->repr->type() == Inkscape::XML::ELEMENT_NODE &&
+            !strcmp(child->repr->name(), tagname)) {
+            return child;
+        }
     }
     return NULL;
 }
 
+/**
+ * Return the full textual content of an element (typically all the
+ * content except the tags).
+ * Must not be used on anything except elements.
+ */
+GString * SPObject::textualContent() const
+{
+    GString* text = g_string_new("");
+
+    for (const SPObject *child = firstChild(); child; child = child->next)
+    {
+        Inkscape::XML::NodeType child_type = child->repr->type();
+
+        if (child_type == Inkscape::XML::ELEMENT_NODE) {
+            GString * new_text = child->textualContent();
+            g_string_append(text, new_text->str);
+            g_string_free(new_text, TRUE);
+        }
+        else if (child_type == Inkscape::XML::TEXT_NODE) {
+            g_string_append(text, child->repr->content());
+        }
+    }
+    return text;
+}
 
 /*
   Local Variables:
@@ -1538,4 +1819,4 @@ sp_object_prev(SPObject *child)
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :