Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2190 insertions, 0 deletions

diff --git a/src/document.cpp b/src/document.cpp
new file mode 100644
index 0000000..a7b1150
--- /dev/null
+++ b/src/document.cpp
@@ -0,0 +1,2190 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * SPDocument manipulation
+ *
+ * Authors:
+ *   Lauris Kaplinski <lauris@kaplinski.com>
+ *   MenTaLguY <mental@rydia.net>
+ *   bulia byak <buliabyak@users.sf.net>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
+ *   Tavmjong Bah <tavmjong@free.fr>
+ *
+ * Copyright (C) 2004-2005 MenTaLguY
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ * Copyright (C) 2012 Tavmjong Bah
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/** \class SPDocument
+ * SPDocument serves as the container of both model trees (agnostic XML
+ * and typed object tree), and implements all of the document-level
+ * functionality used by the program. Many document level operations, like
+ * load, save, print, export and so on, use SPDocument as their basic datatype.
+ *
+ * SPDocument implements undo and redo stacks and an id-based object
+ * dictionary.  Thanks to unique id attributes, the latter can be used to
+ * map from the XML tree back to the object tree.
+ *
+ * SPDocument performs the basic operations needed for asynchronous
+ * update notification (SPObject ::modified virtual method), and implements
+ * the 'modified' signal, as well.
+ */
+
+
+#define noSP_DOCUMENT_DEBUG_IDLE
+#define noSP_DOCUMENT_DEBUG_UNDO
+
+#include <vector>
+#include <string>
+#include <cstring>
+
+#include <2geom/transforms.h>
+
+#include "desktop.h"
+#include "document-undo.h"
+#include "event-log.h"
+#include "file.h"
+#include "id-clash.h"
+#include "inkscape-version.h"
+#include "inkscape.h"
+#include "inkscape-window.h"
+#include "profile-manager.h"
+#include "rdf.h"
+
+#include "actions/actions-edit-document.h"
+#include "actions/actions-undo-document.h"
+#include "actions/actions-pages.h"
+
+#include "display/drawing.h"
+
+#include "3rdparty/adaptagrams/libavoid/router.h"
+
+#include "3rdparty/libcroco/cr-parser.h"
+#include "3rdparty/libcroco/cr-sel-eng.h"
+#include "3rdparty/libcroco/cr-selector.h"
+
+#include "io/dir-util.h"
+#include "layer-manager.h"
+#include "page-manager.h"
+#include "live_effects/lpeobject.h"
+#include "object/persp3d.h"
+#include "object/sp-defs.h"
+#include "object/sp-factory.h"
+#include "object/sp-namedview.h"
+#include "object/sp-root.h"
+#include "object/sp-symbol.h"
+#include "object/sp-page.h"
+
+#include "widgets/desktop-widget.h"
+
+#include "xml/croco-node-iface.h"
+#include "xml/rebase-hrefs.h"
+#include "xml/simple-document.h"
+
+using Inkscape::DocumentUndo;
+using Inkscape::Util::unit_table;
+
+// Higher number means lower priority.
+#define SP_DOCUMENT_UPDATE_PRIORITY (G_PRIORITY_HIGH_IDLE - 2)
+
+// Should have a lower priority than SP_DOCUMENT_UPDATE_PRIORITY,
+// since we want it to happen when there are no more updates.
+#define SP_DOCUMENT_REROUTING_PRIORITY (G_PRIORITY_HIGH_IDLE - 1)
+
+bool sp_no_convert_text_baseline_spacing = false;
+
+//gboolean sp_document_resource_list_free(gpointer key, gpointer value, gpointer data);
+
+static gint doc_count = 0;
+static gint doc_mem_count = 0;
+
+static unsigned long next_serial = 0;
+
+SPDocument::SPDocument() :
+    keepalive(false),
+    virgin(true),
+    rdoc(nullptr),
+    rroot(nullptr),
+    root(nullptr),
+    style_cascade(cr_cascade_new(nullptr, nullptr, nullptr)),
+    document_filename(nullptr),
+    document_base(nullptr),
+    document_name(nullptr),
+    actionkey(),
+    _event_log(new Inkscape::EventLog(this)),
+    profileManager(nullptr), // deferred until after other initialization
+    router(new Avoid::Router(Avoid::PolyLineRouting|Avoid::OrthogonalRouting)),
+    _selection(new Inkscape::Selection(this)),
+    oldSignalsConnected(false),
+    current_persp3d(nullptr),
+    current_persp3d_impl(nullptr),
+    _parent_document(nullptr),
+    _node_cache_valid(false),
+    _activexmltree(nullptr)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    if (!prefs->getBool("/options/yaxisdown", true)) {
+        _doc2dt[3] = -1;
+    }
+
+    // Penalise libavoid for choosing paths with needless extra segments.
+    // This results in much better looking orthogonal connector paths.
+    router->setRoutingPenalty(Avoid::segmentPenalty);
+
+    _serial = next_serial++;
+
+    sensitive = false;
+    partial = nullptr;
+    history_size = 0;
+    seeking = false;
+
+    // Once things are set, hook in the manager
+    profileManager = new Inkscape::ProfileManager(this);
+
+    // For undo/redo
+    undoStackObservers.add(*_event_log);
+
+    // XXX only for testing!
+    undoStackObservers.add(console_output_undo_observer);
+    _node_cache = std::deque<SPItem*>();
+
+    // Actions
+    action_group = Gio::SimpleActionGroup::create();
+    add_actions_edit_document(this);
+    add_actions_pages(this);
+    add_actions_undo_document(this);
+
+    _page_manager = std::make_unique<Inkscape::PageManager>(this);
+}
+
+SPDocument::~SPDocument() {
+    destroySignal.emit();
+
+    // kill/unhook this first
+    if ( profileManager ) {
+        delete profileManager;
+        profileManager = nullptr;
+    }
+
+    if (router) {
+        delete router;
+        router = nullptr;
+    }
+
+    if (oldSignalsConnected) {
+        selChangeConnection.disconnect();
+        desktopActivatedConnection.disconnect();
+    } else {
+        _selection_changed_connection.disconnect();
+        _desktop_activated_connection.disconnect();
+    }
+
+    if (partial) {
+        sp_repr_free_log(partial);
+        partial = nullptr;
+    }
+
+    DocumentUndo::clearRedo(this);
+    DocumentUndo::clearUndo(this);
+
+    if (root) {
+        root->releaseReferences();
+        sp_object_unref(root);
+        root = nullptr;
+    }
+
+    if (rdoc) Inkscape::GC::release(rdoc);
+
+    /* Free resources */
+    resources.clear();
+
+    // This also destroys all attached stylesheets
+    cr_cascade_unref(style_cascade);
+    style_cascade = nullptr;
+
+    if (document_name) {
+        g_free(document_name);
+        document_name = nullptr;
+    }
+    if (document_base) {
+        g_free(document_base);
+        document_base = nullptr;
+    }
+    if (document_filename) {
+        g_free(document_filename);
+        document_filename = nullptr;
+    }
+
+    modified_connection.disconnect();
+    rerouting_connection.disconnect();
+
+    if (keepalive) {
+        inkscape_unref(INKSCAPE);
+        keepalive = false;
+    }
+
+    if (this->current_persp3d_impl)
+        delete this->current_persp3d_impl;
+    this->current_persp3d_impl = nullptr;
+
+    if (_event_log) {
+        delete _event_log;
+    }
+
+    // This is at the end of the destructor, because preceding code adds new orphans to the queue
+    collectOrphans();
+}
+
+Inkscape::XML::Node *SPDocument::getReprNamedView()
+{
+    return sp_repr_lookup_name (rroot, "sodipodi:namedview");
+}
+
+/**
+ * Get the namedview for this document, creates it if it's not found.
+ *
+ * @returns SPNamedView object, existing or created.
+ */
+SPNamedView *SPDocument::getNamedView()
+{
+    auto xml = getReprNamedView();
+    if (!xml) {
+        xml = rdoc->createElement("sodipodi:namedview");
+        rroot->addChildAtPos(xml, 0);
+    }
+    return dynamic_cast<SPNamedView *> (getObjectByRepr(xml));
+}
+
+SPDefs *SPDocument::getDefs()
+{
+    if (!root) {
+        return nullptr;
+    }
+    return root->defs;
+}
+
+Persp3D *SPDocument::getCurrentPersp3D() {
+    // Check if current_persp3d is still valid
+    std::vector<Persp3D*> plist;
+    getPerspectivesInDefs(plist);
+    for (auto & i : plist) {
+        if (current_persp3d == i)
+            return current_persp3d;
+    }
+
+    // If not, return the first perspective in defs (which may be NULL of none exists)
+    current_persp3d = Persp3D::document_first_persp (this);
+
+    return current_persp3d;
+}
+
+void SPDocument::setCurrentPersp3D(Persp3D * const persp) {
+    current_persp3d = persp;
+    //current_persp3d_impl = persp->perspective_impl;
+}
+
+void SPDocument::getPerspectivesInDefs(std::vector<Persp3D*> &list) const
+{
+    for (auto& i: root->defs->children) {
+        if (SP_IS_PERSP3D(&i)) {
+            list.push_back(SP_PERSP3D(&i));
+        }
+    }
+}
+
+/**
+void SPDocument::initialize_current_persp3d()
+{
+    this->current_persp3d = Persp3D::document_first_persp(this);
+    if (!this->current_persp3d) {
+        this->current_persp3d = Persp3D::create_xml_element(this);
+    }
+}
+**/
+
+/**
+ * Enables or disables document pages, usually used in import code.
+ */
+void SPDocument::setPages(bool enabled)
+{
+    if (enabled) {
+        _page_manager->enablePages();
+    } else {
+        _page_manager->disablePages();
+    }
+}
+
+void SPDocument::queueForOrphanCollection(SPObject *object) {
+    g_return_if_fail(object != nullptr);
+    g_return_if_fail(object->document == this);
+
+    sp_object_ref(object, nullptr);
+    _collection_queue.push_back(object);
+}
+
+void SPDocument::collectOrphans() {
+    while (!_collection_queue.empty()) {
+        std::vector<SPObject *> objects(_collection_queue);
+        _collection_queue.clear();
+        for (auto object : objects) {
+            object->collectOrphan();
+            sp_object_unref(object, nullptr);
+        }
+    }
+}
+
+SPDocument *SPDocument::createDoc(Inkscape::XML::Document *rdoc,
+                                  gchar const *filename,
+                                  gchar const *document_base,
+                                  gchar const *document_name,
+                                  bool keepalive,
+                                  SPDocument *parent)
+{
+    SPDocument *document = new SPDocument();
+
+    Inkscape::XML::Node *rroot = rdoc->root();
+
+    document->keepalive = keepalive;
+
+    document->rdoc = rdoc;
+    document->rroot = rroot;
+    if (parent) {
+        document->_parent_document = parent;
+        parent->_child_documents.push_back(document);
+    }
+
+    if (document->document_filename){
+        g_free(document->document_filename);
+        document->document_filename = nullptr;
+    }
+    if (document->document_base){
+        g_free(document->document_base);
+        document->document_base = nullptr;
+    }
+    if (document->document_name){
+        g_free(document->document_name);
+        document->document_name = nullptr;
+    }
+#ifndef _WIN32
+    document->document_filename = prepend_current_dir_if_relative(filename);
+#else
+    // FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
+    document->document_filename = filename? g_strdup(filename) : NULL;
+#endif
+
+    // base is simply the part of the path before filename; e.g. when running "inkscape ../file.svg" the base is "../"
+    // which is why we use g_get_current_dir() in calculating the abs path above
+    //This is NULL for a new document
+    if (document_base) {
+        document->document_base = g_strdup(document_base);
+    } else {
+        document->document_base = nullptr;
+    }
+    document->document_name = g_strdup(document_name);
+
+    // Create SPRoot element
+    const std::string typeString = NodeTraits::get_type_string(*rroot);
+    SPObject* rootObj = SPFactory::createObject(typeString);
+    document->root = dynamic_cast<SPRoot*>(rootObj);
+
+    if (document->root == nullptr) {
+    	// Node is not a valid root element
+    	delete rootObj;
+
+    	// fixme: what to do here?
+    	throw;
+    }
+
+    // Recursively build object tree
+    document->root->invoke_build(document, rroot, false);
+
+    /* Eliminate obsolete sodipodi:docbase, for privacy reasons */
+    rroot->removeAttribute("sodipodi:docbase");
+
+    /* Eliminate any claim to adhere to a profile, as we don't try to */
+    rroot->removeAttribute("baseProfile");
+
+    // loading or creating namedview.
+    auto nv = document->getNamedView();
+
+    // Set each of the defaults in new or existing namedview (allows for per-attr overriding)
+    nv->setDefaultAttribute("pagecolor",                 "/template/base/pagecolor", "");
+    nv->setDefaultAttribute("bordercolor",               "/template/base/bordercolor", "");
+    nv->setDefaultAttribute("borderopacity",             "/template/base/borderopacity", "");
+    nv->setDefaultAttribute("inkscape:showpageshadow",   "/template/base/pageshadow", "2");
+    nv->setDefaultAttribute("inkscape:pageopacity",      "/template/base/pageopacity", "0.0");
+    nv->setDefaultAttribute("inkscape:pagecheckerboard", "/template/base/pagecheckerboard", "0");
+    if (!nv->getAttribute("inkscape:deskcolor")) {
+        auto page = nv->getAttribute("pagecolor");
+        auto color = "#d1d1d1"; // default gray desk
+        if (page && strcasecmp(page, "#ffffff") != 0) {
+            color = page;
+        }
+        nv->setDefaultAttribute("inkscape:deskcolor",    "/template/base/deskcolor", color);
+    }
+
+    // If no units are set in the document, try and guess them from the width/height
+    // XXX Replace these calls with nv->setDocumentUnit(document->root->width.getUnit());
+    if (document->root->width.isAbsolute()) {
+        nv->setDefaultAttribute("inkscape:document-units", "", document->root->width.getUnit());
+    } else if (document->root->height.isAbsolute()) {
+        nv->setDefaultAttribute("inkscape:document-units", "", document->root->height.getUnit());
+    }
+
+    // Defs
+    if (!document->root->defs) {
+        Inkscape::XML::Node *r = rdoc->createElement("svg:defs");
+        rroot->addChild(r, nullptr);
+        Inkscape::GC::release(r);
+        g_assert(document->root->defs);
+    }
+
+    /* Default RDF */
+    rdf_set_defaults( document );
+
+    if (keepalive) {
+        inkscape_ref(INKSCAPE);
+    }
+
+    // Check if the document already has a perspective (e.g., when opening an existing
+    // document). If not, create a new one and set it as the current perspective.
+    document->setCurrentPersp3D(Persp3D::document_first_persp(document));
+    if (!document->getCurrentPersp3D()) {
+        //document->setCurrentPersp3D(Persp3D::create_xml_element (document));
+        Persp3DImpl *persp_impl = new Persp3DImpl();
+        document->setCurrentPersp3DImpl(persp_impl);
+    }
+
+    DocumentUndo::setUndoSensitive(document, true);
+
+    // reset undo key when selection changes, so that same-key actions on different objects are not coalesced
+    document->selChangeConnection = INKSCAPE.signal_selection_changed.connect(
+                sigc::hide(sigc::bind(
+                sigc::ptr_fun(&DocumentUndo::resetKey), document)
+    ));
+    document->desktopActivatedConnection = INKSCAPE.signal_activate_desktop.connect(
+                sigc::hide(sigc::bind(
+                sigc::ptr_fun(&DocumentUndo::resetKey), document)
+    ));
+    document->oldSignalsConnected = true;
+
+
+    // ************* Fix Document **************
+    // Move to separate function?
+
+    /** Fix baseline spacing (pre-92 files) **/
+    if ( (!sp_no_convert_text_baseline_spacing)
+         && sp_version_inside_range( document->root->version.inkscape, 0, 1, 0, 92 ) ) {
+        sp_file_convert_text_baseline_spacing(document);
+    }
+
+    /** Fix font names in legacy documents (pre-92 files) **/
+    if ( sp_version_inside_range( document->root->version.inkscape, 0, 1, 0, 92 ) ) {
+        sp_file_convert_font_name(document);
+    }
+
+    /** Fix first line spacing in legacy documents (pre-1.0 files) **/
+    if (sp_version_inside_range(document->root->version.inkscape, 0, 1, 1, 0)) {
+        sp_file_fix_empty_lines(document);
+    }
+
+    /** Fix OSB (pre-1.1 files) **/
+    if (sp_version_inside_range(document->root->version.inkscape, 0, 1, 1, 1)) {
+        sp_file_fix_osb(document->getRoot());
+    }
+
+    /** Fix feComposite (pre-1.2 files) **/
+    if (sp_version_inside_range(document->root->version.inkscape, 0, 1, 1, 2)) {
+        sp_file_fix_feComposite(document->getRoot());
+    }
+
+
+    /** Fix dpi (pre-92 files). With GUI fixed in Inkscape::Application::fix_document. **/
+    if ( !(INKSCAPE.use_gui()) && sp_version_inside_range( document->root->version.inkscape, 0, 1, 0, 92 ) ) {
+        sp_file_convert_dpi(document);
+    }
+
+    // Update document level action settings
+    // -- none available so far --
+
+    return document;
+}
+
+/**
+ * Create a copy of the document, useful for modifying during save & export.
+ */
+std::unique_ptr<SPDocument> SPDocument::copy() const
+{
+    // New SimpleDocument object where we will put all the same data
+    Inkscape::XML::Document *new_rdoc = new Inkscape::XML::SimpleDocument();
+
+    // Duplicate the svg root node AND any PI and COMMENT nodes, this should be put
+    // into xml/simple-document.h at some point to fix it's duplicate implementation.
+    for (Inkscape::XML::Node *child = rdoc->firstChild(); child; child = child->next()) {
+        if (child) {
+            // Get a new xml repr for the svg root node
+            Inkscape::XML::Node *new_child = child->duplicate(new_rdoc);
+
+            // Add the duplicated svg node as the document's rdoc
+            new_rdoc->appendChild(new_child);
+            Inkscape::GC::release(new_child);
+        }
+    }
+
+    auto doc = createDoc(new_rdoc, document_filename, document_base, document_name, keepalive, nullptr);
+    doc->_original_document = this;
+
+    return doc->doRef();
+}
+
+/**
+ * Fetches a document and attaches it to the current document as a child href
+ */
+SPDocument *SPDocument::createChildDoc(std::string const &filename)
+{
+    SPDocument *parent = this;
+    SPDocument *document = nullptr;
+
+    while(parent != nullptr && parent->getDocumentFilename() != nullptr && document == nullptr) {
+        // Check myself and any parents in the chain
+        if(filename == parent->getDocumentFilename()) {
+            document = parent;
+            break;
+        }
+        // Then check children of those.
+        boost::ptr_list<SPDocument>::iterator iter;
+        for (iter = parent->_child_documents.begin();
+          iter != parent->_child_documents.end(); ++iter) {
+            if(filename == iter->getDocumentFilename()) {
+                document = &*iter;
+                break;
+            }
+        }
+        parent = parent->_parent_document;
+    }
+
+    // Load a fresh document from the svg source.
+    if(!document) {
+        std::string path;
+        if (Glib::path_is_absolute(filename)) {
+            path = filename;
+        } else {
+            path = this->getDocumentBase() + filename;
+        }
+        document = createNewDoc(path.c_str(), false, false, this);
+    }
+    return document;
+}
+/**
+ * Fetches document from filename, or creates new, if NULL; public document
+ * appears in document list.
+ */
+SPDocument *SPDocument::createNewDoc(gchar const *filename, bool keepalive, bool make_new, SPDocument *parent)
+{
+    Inkscape::XML::Document *rdoc = nullptr;
+    gchar *document_base = nullptr;
+    gchar *document_name = nullptr;
+
+    if (filename) {
+        Inkscape::XML::Node *rroot;
+        /* Try to fetch repr from file */
+        rdoc = sp_repr_read_file(filename, SP_SVG_NS_URI);
+        /* If file cannot be loaded, return NULL without warning */
+        if (rdoc == nullptr) return nullptr;
+        rroot = rdoc->root();
+        /* If xml file is not svg, return NULL without warning */
+        /* fixme: destroy document */
+        if (strcmp(rroot->name(), "svg:svg") != 0) return nullptr;
+
+        // Opening a template that points to a sister file should still work
+        // this also includes tutorials which point to png files.
+        document_base = g_path_get_dirname(filename);
+
+        if (make_new) {
+            filename = nullptr;
+            document_name = g_strdup_printf(_("New document %d"), ++doc_count);
+        } else {
+            document_name = g_path_get_basename(filename);
+            if (strcmp(document_base, ".") == 0) {
+                g_free(document_base);
+                document_base = nullptr;
+            }
+        }
+    } else {
+        if (make_new) {
+            document_name = g_strdup_printf(_("Memory document %d"), ++doc_mem_count);
+        }
+
+        rdoc = sp_repr_document_new("svg:svg");
+    }
+
+    //# These should be set by now
+    g_assert(document_name);
+
+    SPDocument *doc = createDoc(rdoc, filename, document_base, document_name, keepalive, parent);
+
+    g_free(document_base);
+    g_free(document_name);
+
+    return doc;
+}
+
+SPDocument *SPDocument::createNewDocFromMem(gchar const *buffer, gint length, bool keepalive)
+{
+    SPDocument *doc = nullptr;
+
+    Inkscape::XML::Document *rdoc = sp_repr_read_mem(buffer, length, SP_SVG_NS_URI);
+    if ( rdoc ) {
+        // Only continue to create a non-null doc if it could be loaded
+        Inkscape::XML::Node *rroot = rdoc->root();
+        if ( strcmp(rroot->name(), "svg:svg") != 0 ) {
+            // If xml file is not svg, return NULL without warning
+            // TODO fixme: destroy document
+        } else {
+            Glib::ustring document_name = Glib::ustring::compose( _("Memory document %1"), ++doc_mem_count );
+            doc = createDoc(rdoc, nullptr, nullptr, document_name.c_str(), keepalive, nullptr);
+        }
+    }
+
+    return doc;
+}
+
+std::unique_ptr<SPDocument> SPDocument::doRef()
+{
+    Inkscape::GC::anchor(this);
+    return std::unique_ptr<SPDocument>(this);
+}
+std::unique_ptr<SPDocument const> SPDocument::doRef() const
+{
+    return const_cast<SPDocument*>(this)->doRef();
+}
+
+/// guaranteed not to return nullptr
+Inkscape::Util::Unit const* SPDocument::getDisplayUnit()
+{
+    return getNamedView()->getDisplayUnit();
+}
+
+/// Sets document scale (by changing viewBox)
+void SPDocument::setDocumentScale(double scaleX, double scaleY) {
+    if (scaleX <= 0 || scaleY <= 0) {
+        g_warning("%s: Invalid scale, has to be positive: %f, %f", __func__, scaleX, scaleY);
+        return;
+    }
+
+    // since scale is doc size / viewbox size, then it follows that viewbox size is doc size / scale
+    root->viewBox = Geom::Rect::from_xywh(
+        root->viewBox.left(),
+        root->viewBox.top(),
+        root->width.computed  / scaleX,
+        root->height.computed / scaleY);
+    root->viewBox_set = true;
+    root->updateRepr();
+}
+
+/// Sets document scale (by changing viewBox, x and y scaling equal)
+void SPDocument::setDocumentScale(double scale) {
+    setDocumentScale(scale, scale);
+}
+
+/// Returns document scale as defined by width/height (in pixels) and viewBox (real world to
+/// user-units).
+Geom::Scale SPDocument::getDocumentScale() const
+{
+    Geom::Scale scale;
+    if( root->viewBox_set ) {
+        double scale_x = 1.0;
+        double scale_y = 1.0;
+        if( root->viewBox.width() > 0.0 ) {
+            scale_x = root->width.computed / root->viewBox.width();
+        }
+        if( root->viewBox.height() > 0.0 ) {
+            scale_y = root->height.computed / root->viewBox.height();
+        }
+        scale = Geom::Scale(scale_x, scale_y);
+    }
+    // std::cout << "SPDocument::getDocumentScale():\n" << scale << std::endl;
+    return scale;
+}
+
+// Avoid calling root->updateRepr() twice by combining setting width and height.
+// (As done on every delete as clipboard calls this via fitToRect())
+void SPDocument::setWidthAndHeight(const Inkscape::Util::Quantity &width, const Inkscape::Util::Quantity &height, bool changeSize)
+{
+    Inkscape::Util::Unit const *old_width_units = unit_table.getUnit("px");
+    if (root->width.unit)
+        old_width_units = unit_table.getUnit(root->width.unit);
+    gdouble old_width_converted;  // old width converted to new units
+    if (root->width.unit == SVGLength::PERCENT)
+        old_width_converted = Inkscape::Util::Quantity::convert(root->width.computed, "px", width.unit);
+    else
+        old_width_converted = Inkscape::Util::Quantity::convert(root->width.value, old_width_units, width.unit);
+
+    root->width.computed = width.value("px");
+    root->width.value = width.quantity;
+    root->width.unit = (SVGLength::Unit) width.unit->svgUnit();
+
+    Inkscape::Util::Unit const *old_height_units = unit_table.getUnit("px");
+    if (root->height.unit)
+        old_height_units = unit_table.getUnit(root->height.unit);
+    gdouble old_height_converted;  // old height converted to new units
+    if (root->height.unit == SVGLength::PERCENT)
+        old_height_converted = Inkscape::Util::Quantity::convert(root->height.computed, "px", height.unit);
+    else
+        old_height_converted = Inkscape::Util::Quantity::convert(root->height.value, old_height_units, height.unit);
+
+    root->height.computed = height.value("px");
+    root->height.value = height.quantity;
+    root->height.unit = (SVGLength::Unit) height.unit->svgUnit();
+
+    // viewBox scaled by relative change in page size (maintains document scale).
+    if (root->viewBox_set && changeSize) {
+        root->viewBox.setMax(Geom::Point(
+        root->viewBox.left() + (root->width.value /  old_width_converted ) * root->viewBox.width(),
+        root->viewBox.top()  + (root->height.value / old_height_converted) * root->viewBox.height()));
+    }
+    root->updateRepr();
+}
+
+Inkscape::Util::Quantity SPDocument::getWidth() const
+{
+    g_return_val_if_fail(this->root != nullptr, Inkscape::Util::Quantity(0.0, unit_table.getUnit("")));
+
+    gdouble result = root->width.value;
+    SVGLength::Unit u = root->width.unit;
+    if (root->width.unit == SVGLength::PERCENT && root->viewBox_set) {
+        result = root->viewBox.width();
+        u = SVGLength::PX;
+    }
+    if (u == SVGLength::NONE) {
+        u = SVGLength::PX;
+    }
+    return Inkscape::Util::Quantity(result, unit_table.getUnit(u));
+}
+
+void SPDocument::setWidth(const Inkscape::Util::Quantity &width, bool changeSize)
+{
+    Inkscape::Util::Unit const *old_width_units = unit_table.getUnit("px");
+    if (root->width.unit)
+        old_width_units = unit_table.getUnit(root->width.unit);
+    gdouble old_width_converted;  // old width converted to new units
+    if (root->width.unit == SVGLength::PERCENT)
+        old_width_converted = Inkscape::Util::Quantity::convert(root->width.computed, "px", width.unit);
+    else
+        old_width_converted = Inkscape::Util::Quantity::convert(root->width.value, old_width_units, width.unit);
+
+    root->width.computed = width.value("px");
+    root->width.value = width.quantity;
+    root->width.unit = (SVGLength::Unit) width.unit->svgUnit();
+
+    if (root->viewBox_set && changeSize)
+        root->viewBox.setMax(Geom::Point(root->viewBox.left() + (root->width.value / old_width_converted) * root->viewBox.width(), root->viewBox.bottom()));
+
+    root->updateRepr();
+}
+
+
+Inkscape::Util::Quantity SPDocument::getHeight() const
+{
+    g_return_val_if_fail(this->root != nullptr, Inkscape::Util::Quantity(0.0, unit_table.getUnit("")));
+
+    gdouble result = root->height.value;
+    SVGLength::Unit u = root->height.unit;
+    if (root->height.unit == SVGLength::PERCENT && root->viewBox_set) {
+        result = root->viewBox.height();
+        u = SVGLength::PX;
+    }
+    if (u == SVGLength::NONE) {
+        u = SVGLength::PX;
+    }
+    return Inkscape::Util::Quantity(result, unit_table.getUnit(u));
+}
+
+void SPDocument::setHeight(const Inkscape::Util::Quantity &height, bool changeSize)
+{
+    Inkscape::Util::Unit const *old_height_units = unit_table.getUnit("px");
+    if (root->height.unit)
+        old_height_units = unit_table.getUnit(root->height.unit);
+    gdouble old_height_converted;  // old height converted to new units
+    if (root->height.unit == SVGLength::PERCENT)
+        old_height_converted = Inkscape::Util::Quantity::convert(root->height.computed, "px", height.unit);
+    else
+        old_height_converted = Inkscape::Util::Quantity::convert(root->height.value, old_height_units, height.unit);
+
+    root->height.computed = height.value("px");
+    root->height.value = height.quantity;
+    root->height.unit = (SVGLength::Unit) height.unit->svgUnit();
+
+    if (root->viewBox_set && changeSize)
+        root->viewBox.setMax(Geom::Point(root->viewBox.right(), root->viewBox.top() + (root->height.value / old_height_converted) * root->viewBox.height()));
+
+    root->updateRepr();
+}
+
+const Geom::Affine &SPDocument::doc2dt() const
+{
+    if (root && !is_yaxisdown()) {
+        _doc2dt[5] = root->height.computed;
+    }
+
+    return _doc2dt;
+}
+
+Geom::Rect SPDocument::getViewBox() const
+{
+    Geom::Rect viewBox;
+    if (root->viewBox_set) {
+        viewBox = root->viewBox;
+    } else {
+        viewBox = Geom::Rect::from_xywh( 0, 0, getWidth().value("px"), getHeight().value("px"));
+    }
+    return viewBox;
+}
+
+/**
+ * Set default viewbox calculated from document properties.
+ */
+void SPDocument::setViewBox()
+{
+    setViewBox(Geom::Rect(0,
+                          0,
+                          getWidth().value(getDisplayUnit()),
+                          getHeight().value(getDisplayUnit())));
+}
+
+void SPDocument::setViewBox(const Geom::Rect &viewBox)
+{
+    root->viewBox_set = true;
+    root->viewBox = viewBox;
+    root->updateRepr();
+}
+
+Geom::Point SPDocument::getDimensions() const
+{
+    return Geom::Point(getWidth().value("px"), getHeight().value("px"));
+}
+
+Geom::OptRect SPDocument::preferredBounds() const
+{
+    return Geom::OptRect( Geom::Point(0, 0), getDimensions() );
+}
+
+/**
+ * Returns the position of the selected page or the preferredBounds()
+ */
+Geom::OptRect SPDocument::pageBounds()
+{
+    if (auto page = _page_manager->getSelected()) {
+        return page->getDesktopRect();
+    }
+    return preferredBounds();
+}
+
+/**
+ * Given a Geom::Rect that may, for example, correspond to the bbox of an object,
+ * this function fits the canvas to that rect by resizing the canvas
+ * and translating the document root into position.
+ * \param rect fit document size to this, in document coordinates
+ * \param with_margins add margins to rect, by taking margins from this
+ *        document's namedview (<sodipodi:namedview> "fit-margin-..."
+ *        attributes, and "units")
+ */
+void SPDocument::fitToRect(Geom::Rect const &rect, bool with_margins)
+{
+    double const w = rect.width();
+    double const h = rect.height();
+
+    Inkscape::Util::Unit const *nv_units = unit_table.getUnit("px");
+    if (root->height.unit && (root->height.unit != SVGLength::PERCENT))
+        nv_units = unit_table.getUnit(root->height.unit);
+    SPNamedView *nv = this->getNamedView();
+
+    /* in px */
+    double margin_top = 0.0;
+    double margin_left = 0.0;
+    double margin_right = 0.0;
+    double margin_bottom = 0.0;
+
+    if (with_margins && nv) {
+        margin_top = nv->getMarginLength("fit-margin-top", nv_units, unit_table.getUnit("px"), w, h, false);
+        margin_left = nv->getMarginLength("fit-margin-left", nv_units, unit_table.getUnit("px"), w, h, true);
+        margin_right = nv->getMarginLength("fit-margin-right", nv_units, unit_table.getUnit("px"), w, h, true);
+        margin_bottom = nv->getMarginLength("fit-margin-bottom", nv_units, unit_table.getUnit("px"), w, h, false);
+        margin_top = Inkscape::Util::Quantity::convert(margin_top, nv_units, "px");
+        margin_left = Inkscape::Util::Quantity::convert(margin_left, nv_units, "px");
+        margin_right = Inkscape::Util::Quantity::convert(margin_right, nv_units, "px");
+        margin_bottom = Inkscape::Util::Quantity::convert(margin_bottom, nv_units, "px");
+    }
+
+    Geom::Rect const rect_with_margins(
+            rect.min() - Geom::Point(margin_left, margin_top),
+            rect.max() + Geom::Point(margin_right, margin_bottom));
+
+    // rect in desktop coordinates before changing document dimensions
+    auto rect_with_margins_dt_old = rect_with_margins * doc2dt();
+
+    setWidthAndHeight(
+        Inkscape::Util::Quantity(Inkscape::Util::Quantity::convert(rect_with_margins.width(),  "px", nv_units), nv_units),
+        Inkscape::Util::Quantity(Inkscape::Util::Quantity::convert(rect_with_margins.height(), "px", nv_units), nv_units)
+        );
+
+    // rect in desktop coordinates after changing document dimensions
+    auto rect_with_margins_dt_new = rect_with_margins * doc2dt();
+
+    bool y_down = is_yaxisdown();
+
+    // Translate drawing contents to the origin
+    double const box_x = rect_with_margins_dt_new[Geom::X].min();
+    double const box_y = y_down ? rect_with_margins_dt_new[Geom::Y].min()
+        : rect_with_margins_dt_new.height() - rect_with_margins_dt_old[Geom::Y].max();
+    auto const corrective_translation = Geom::Translate(-box_x, -box_y);
+    root->translateChildItems(corrective_translation);
+
+    if (nv) {
+        // Calculate the required translation of on-canvas gadgets
+        double const delta_x = rect_with_margins_dt_old[Geom::X].min();
+        double const delta_y = y_down ? rect_with_margins_dt_old[Geom::Y].min()
+            : rect_with_margins_dt_new.height() - rect_with_margins_dt_new[Geom::Y].max();
+        auto const on_canvas_gadget_translation = Geom::Translate(-delta_x, -delta_y);
+
+        nv->translateGuides(on_canvas_gadget_translation);
+        nv->translateGrids(on_canvas_gadget_translation);
+        _page_manager->movePages(corrective_translation);
+        nv->scrollAllDesktops(delta_x, delta_y * yaxisdir(), false);
+    }
+}
+
+void SPDocument::setDocumentBase( gchar const* document_base )
+{
+    if (this->document_base) {
+        g_free(this->document_base);
+        this->document_base = nullptr;
+    }
+    if (document_base) {
+        this->document_base = g_strdup(document_base);
+    }
+}
+
+void SPDocument::do_change_filename(gchar const *const filename, bool const rebase)
+{
+    gchar *new_document_base = nullptr;
+    gchar *new_document_name = nullptr;
+    gchar *new_document_filename = nullptr;
+    if (filename) {
+
+#ifndef _WIN32
+        new_document_filename = prepend_current_dir_if_relative(filename);
+#else
+        // FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!
+        new_document_filename = g_strdup(filename);
+#endif
+
+        new_document_base = g_path_get_dirname(new_document_filename);
+        new_document_name = g_path_get_basename(new_document_filename);
+    } else {
+        new_document_filename = g_strdup_printf(_("Unnamed document %d"), ++doc_count);
+        new_document_base = nullptr;
+        new_document_name = g_strdup(this->document_filename);
+    }
+
+    // Update saveable repr attributes.
+    Inkscape::XML::Node *repr = getReprRoot();
+
+    // Changing filename in the document repr must not be not undoable.
+    bool const saved = DocumentUndo::getUndoSensitive(this);
+    DocumentUndo::setUndoSensitive(this, false);
+
+    if (rebase) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        bool use_sodipodi_absref = prefs->getBool("/options/svgoutput/usesodipodiabsref", false);
+        Inkscape::XML::rebase_hrefs(this, new_document_base, use_sodipodi_absref);
+    }
+
+    if (strncmp(new_document_name, "ink_ext_XXXXXX", 14))	// do not use temporary filenames
+        repr->setAttribute("sodipodi:docname", new_document_name);
+    DocumentUndo::setUndoSensitive(this, saved);
+
+
+    g_free(this->document_name);
+    g_free(this->document_base);
+    g_free(this->document_filename);
+    this->document_name = new_document_name;
+    this->document_base = new_document_base;
+    this->document_filename = new_document_filename;
+
+    this->filename_set_signal.emit(this->document_filename);
+}
+
+/**
+ * Sets base, name and filename members of \a document.  Doesn't update
+ * any relative hrefs in the document: thus, this is primarily for
+ * newly-created documents.
+ *
+ * \see SPDocument::changeFilenameAndHrefs
+ */
+void SPDocument::setDocumentFilename(gchar const *filename)
+{
+    do_change_filename(filename, false);
+}
+
+/**
+ * Changes the base, name and filename members of \a document, and updates any
+ * relative hrefs in the document to be relative to the new base.
+ */
+void SPDocument::changeFilenameAndHrefs(gchar const *filename)
+{
+    do_change_filename(filename, true);
+}
+
+void SPDocument::bindObjectToId(gchar const *id, SPObject *object) {
+    GQuark idq = g_quark_from_string(id);
+
+    if (object) {
+        if(object->getId())
+            iddef.erase(object->getId());
+        g_assert(iddef.find(id)==iddef.end());
+        iddef[id] = object;
+    } else {
+        g_assert(iddef.find(id)!=iddef.end());
+        iddef.erase(id);
+    }
+
+    SPDocument::IDChangedSignalMap::iterator pos;
+
+    pos = id_changed_signals.find(idq);
+    if ( pos != id_changed_signals.end() ) {
+        if (!(*pos).second.empty()) {
+            (*pos).second.emit(object);
+        } else { // discard unused signal
+            id_changed_signals.erase(pos);
+        }
+    }
+}
+
+SPObject *SPDocument::getObjectById(Glib::ustring const &id) const
+{
+    if (iddef.empty()) {
+        return nullptr;
+    }
+
+    std::map<std::string, SPObject *>::const_iterator rv = iddef.find(id);
+    if (rv != iddef.end()) {
+        return (rv->second);
+    } else if (_parent_document) {
+        return _parent_document->getObjectById(id);
+    }
+    else if (_ref_document) {
+        return _ref_document->getObjectById(id);
+    } else {
+        return nullptr;
+    }
+}
+
+SPObject *SPDocument::getObjectById(gchar const *id) const
+{
+    if (id == nullptr) {
+        return nullptr;
+    }
+
+    return getObjectById(Glib::ustring(id));
+}
+
+SPObject *SPDocument::getObjectByHref(Glib::ustring const &href) const
+{
+    if (iddef.empty()) {
+        return nullptr;
+    }
+    Glib::ustring id = href;
+    id = id.erase(0, 1);
+    return getObjectById(id);
+}
+
+SPObject *SPDocument::getObjectByHref(gchar const *href) const
+{
+    if (href == nullptr) {
+        return nullptr;
+    }
+
+    return getObjectByHref(Glib::ustring(href));
+}
+
+void _getObjectsByClassRecursive(Glib::ustring const &klass, SPObject *parent, std::vector<SPObject *> &objects)
+{
+    if (parent) {
+        char const *temp = parent->getAttribute("class");
+        if (temp) {
+            std::istringstream classes(temp);
+            Glib::ustring token;
+            while (classes >> token) {
+                // we can have multiple class
+                if (classes.str() == " ") {
+                    token = "";
+                    continue;
+                }
+                if (token == klass) {
+                    objects.push_back(parent);
+                    break;
+                }
+            }
+        }
+
+        // Check children
+        for (auto& child : parent->children) {
+            _getObjectsByClassRecursive( klass, &child, objects );
+        }
+    }
+}
+
+std::vector<SPObject *> SPDocument::getObjectsByClass(Glib::ustring const &klass) const
+{
+    std::vector<SPObject *> objects;
+    g_return_val_if_fail(!klass.empty(), objects);
+
+    _getObjectsByClassRecursive(klass, root, objects);
+    return objects;
+}
+
+void _getObjectsByElementRecursive(Glib::ustring const &element, SPObject *parent, std::vector<SPObject *> &objects,
+                                   bool custom)
+{
+    if (parent) {
+        Glib::ustring prefixed = custom ? "inkscape:" : "svg:";
+        prefixed += element;
+        if (parent->getRepr()->name() == prefixed) {
+            objects.push_back(parent);
+        }
+
+        // Check children
+        for (auto& child : parent->children) {
+            _getObjectsByElementRecursive(element, &child, objects, custom);
+        }
+    }
+}
+
+std::vector<SPObject *> SPDocument::getObjectsByElement(Glib::ustring const &element, bool custom) const
+{
+    std::vector<SPObject *> objects;
+    g_return_val_if_fail(!element.empty(), objects);
+
+    _getObjectsByElementRecursive(element, root, objects, custom);
+    return objects;
+}
+
+void _getObjectsBySelectorRecursive(SPObject *parent,
+                                    CRSelEng *sel_eng, CRSimpleSel *simple_sel,
+                                    std::vector<SPObject *> &objects)
+{
+    if (parent) {
+        gboolean result = false;
+        cr_sel_eng_matches_node( sel_eng, simple_sel, parent->getRepr(), &result );
+        if (result) {
+            objects.push_back(parent);
+        }
+
+        // Check children
+        for (auto& child : parent->children) {
+            _getObjectsBySelectorRecursive(&child, sel_eng, simple_sel, objects);
+        }
+    }
+}
+
+std::vector<SPObject *> SPDocument::getObjectsBySelector(Glib::ustring const &selector) const
+{
+    // std::cout << "\nSPDocument::getObjectsBySelector: " << selector << std::endl;
+
+    std::vector<SPObject *> objects;
+    g_return_val_if_fail(!selector.empty(), objects);
+
+    static CRSelEng *sel_eng = nullptr;
+    if (!sel_eng) {
+        sel_eng = cr_sel_eng_new(&Inkscape::XML::croco_node_iface);
+    }
+
+    CRSelector *cr_selector = cr_selector_parse_from_buf((guchar const *)selector.c_str(), CR_UTF_8);
+    // char * cr_string = (char*)cr_selector_to_string( cr_selector );
+    // std::cout << "  selector: |" << (cr_string?cr_string:"Empty") << "|" << std::endl;
+    CRSelector const *cur = nullptr;
+    for (cur = cr_selector; cur; cur = cur->next) {
+        if (cur->simple_sel ) {
+            _getObjectsBySelectorRecursive(root, sel_eng, cur->simple_sel, objects);
+        }
+    }
+    return objects;
+}
+
+void SPDocument::bindObjectToRepr(Inkscape::XML::Node *repr, SPObject *object)
+{
+    if (object) {
+        g_assert(reprdef.find(repr)==reprdef.end());
+        reprdef[repr] = object;
+    } else {
+        g_assert(reprdef.find(repr)!=reprdef.end());
+        reprdef.erase(repr);
+    }
+}
+
+SPObject *SPDocument::getObjectByRepr(Inkscape::XML::Node *repr) const
+{
+    g_return_val_if_fail(repr != nullptr, NULL);
+    std::map<Inkscape::XML::Node *, SPObject *>::const_iterator rv = reprdef.find(repr);
+    if(rv != reprdef.end())
+        return (rv->second);
+    else
+        return nullptr;
+}
+
+/** Returns preferred document languages (from most to least preferred)
+ *
+ * This currently includes (in order):
+ * - language set in RDF metadata
+ * - languages suitable for system locale (influenced by Inkscape GUI locale preference)
+ */
+std::vector<Glib::ustring> SPDocument::getLanguages() const
+{
+    std::vector<Glib::ustring> document_languages;
+
+    // get language from RDF
+    gchar const *rdf_language = rdf_get_work_entity(this, rdf_find_entity("language"));
+    if (rdf_language) {
+        gchar *rdf_language_stripped = g_strstrip(g_strdup(rdf_language));
+        if (strcmp(rdf_language_stripped, "") != 0) {
+            document_languages.emplace_back(rdf_language_stripped);
+        }
+        g_free(rdf_language_stripped);
+    }
+
+    // add languages from parent document
+    if (_parent_document) {
+        auto parent_languages = _parent_document->getLanguages();
+
+        // return parent languages directly if we aren't contributing any
+        if (document_languages.empty()) {
+            return parent_languages;
+        }
+
+        // otherwise append parent's languages to what we already have
+        std::move(parent_languages.begin(), parent_languages.end(),
+                  std::back_insert_iterator(document_languages));
+
+        // don't add languages from locale; parent already did that
+        return document_languages;
+    }
+
+    // get language from system locale (will also match the interface language preference as we set LANG accordingly)
+    // TODO: This includes locales with encodings like "de_DE.UTF-8" - is this useful or should we skip these?
+    // TODO: This includes the default "C" locale - is this useful or should we skip it?
+    const gchar * const * names = g_get_language_names();
+    for (int i=0; names[i]; i++) {
+        document_languages.emplace_back(names[i]);
+    }
+
+    return document_languages;
+}
+
+/* Object modification root handler */
+
+void SPDocument::requestModified()
+{
+    if (modified_connection.empty()) {
+        modified_connection =
+            Glib::signal_idle().connect(sigc::mem_fun(*this, &SPDocument::idle_handler),
+                                        SP_DOCUMENT_UPDATE_PRIORITY);
+    }
+
+    if (rerouting_connection.empty()) {
+        rerouting_connection =
+            Glib::signal_idle().connect(sigc::mem_fun(*this, &SPDocument::rerouting_handler),
+                                        SP_DOCUMENT_REROUTING_PRIORITY);
+    }
+}
+
+void SPDocument::setupViewport(SPItemCtx *ctx)
+{
+    ctx->flags = 0;
+    ctx->i2doc = Geom::identity();
+    // Set up viewport in case svg has it defined as percentages
+    if (root->viewBox_set) { // if set, take from viewBox
+        ctx->viewport = root->viewBox;
+    } else { // as a last resort, set size to A4
+        ctx->viewport = Geom::Rect::from_xywh(0, 0, Inkscape::Util::Quantity::convert(210, "mm", "px"), Inkscape::Util::Quantity::convert(297, "mm", "px"));
+    }
+    ctx->i2vp = Geom::identity();
+}
+
+/**
+ * Tries to update the document state based on the modified and
+ * "update required" flags, and return true if the document has
+ * been brought fully up to date.
+ */
+bool
+SPDocument::_updateDocument(int update_flags)
+{
+    /* Process updates */
+    if (this->root->uflags || this->root->mflags) {
+        if (this->root->uflags) {
+            SPItemCtx ctx;
+            setupViewport(&ctx);
+
+            DocumentUndo::ScopedInsensitive _no_undo(this);
+
+            this->root->updateDisplay((SPCtx *)&ctx, update_flags);
+        }
+        this->_emitModified();
+    }
+
+    return !(this->root->uflags || this->root->mflags);
+}
+
+
+/**
+ * Repeatedly works on getting the document updated, since sometimes
+ * it takes more than one pass to get the document updated.  But it
+ * usually should not take more than a few loops, and certainly never
+ * more than 32 iterations.  So we bail out if we hit 32 iterations,
+ * since this typically indicates we're stuck in an update loop.
+ */
+gint SPDocument::ensureUpToDate()
+{
+    // Bring the document up-to-date, specifically via the following:
+    //   1a) Process all document updates.
+    //   1b) When completed, process connector routing changes.
+    //   2a) Process any updates resulting from connector reroutings.
+    int counter = 32;
+    for (unsigned int pass = 1; pass <= 2; ++pass) {
+        // Process document updates.
+        while (!_updateDocument(0)) {
+            if (counter == 0) {
+                g_warning("More than 32 iteration while updating document '%s'", document_filename);
+                break;
+            }
+            counter--;
+        }
+        if (counter == 0)
+        {
+            break;
+        }
+
+        // After updates on the first pass we get libavoid to process all the
+        // changed objects and provide new routings.  This may cause some objects
+            // to be modified, hence the second update pass.
+        if (pass == 1) {
+            router->processTransaction();
+        }
+    }
+
+    // Remove handlers
+    modified_connection.disconnect();
+    rerouting_connection.disconnect();
+
+    return (counter > 0);
+}
+
+/**
+ * An idle handler to update the document.  Returns true if
+ * the document needs further updates.
+ */
+bool
+SPDocument::idle_handler()
+{
+    bool status = !_updateDocument(0); // method TRUE if it does NOT need further modification, so invert
+    if (!status) {
+        modified_connection.disconnect();
+    }
+    return status;
+}
+
+/**
+ * An idle handler to reroute connectors in the document.
+ */
+bool
+SPDocument::rerouting_handler()
+{
+    // Process any queued movement actions and determine new routings for
+    // object-avoiding connectors.  Callbacks will be used to update and
+    // redraw affected connectors.
+    router->processTransaction();
+
+    // We don't need to handle rerouting again until there are further
+    // diagram updates.
+    return false;
+}
+
+static bool is_within(Geom::Rect const &area, Geom::Rect const &box)
+{
+    return area.contains(box);
+}
+
+static bool overlaps(Geom::Rect const &area, Geom::Rect const &box)
+{
+    return area.intersects(box);
+}
+
+/**
+ * @param area Area in document coordinates
+ */
+static std::vector<SPItem*> &find_items_in_area(std::vector<SPItem*> &s,
+                                                SPGroup *group, unsigned int dkey,
+                                                Geom::Rect const &area,
+                                                bool (*test)(Geom::Rect const &, Geom::Rect const &),
+                                                bool take_hidden = false,
+                                                bool take_insensitive = false,
+                                                bool take_groups = true,
+                                                bool enter_groups = false)
+{
+    g_return_val_if_fail(SP_IS_GROUP(group), s);
+
+    for (auto& o: group->children) {
+        if (SPItem *item = dynamic_cast<SPItem *>(&o)) {
+            if (!take_insensitive && item->isLocked()) {
+                continue;
+            }
+
+            if (!take_hidden && item->isHidden()) {
+                continue;
+            }
+
+            if (SPGroup * childgroup = dynamic_cast<SPGroup *>(item)) {
+                bool is_layer = childgroup->effectiveLayerMode(dkey) == SPGroup::LAYER;
+                if (is_layer || (enter_groups)) {
+                    s = find_items_in_area(s, childgroup, dkey, area, test, take_hidden, take_insensitive, take_groups, enter_groups);
+                }
+                if (!take_groups || is_layer) {
+                    continue;
+                }
+            }
+            Geom::OptRect box = item->documentVisualBounds();
+            if (box && test(area, *box)) {
+                s.push_back(item);
+            }
+        }
+    }
+    return s;
+}
+
+SPItem *SPDocument::getItemFromListAtPointBottom(unsigned int dkey, SPGroup *group, std::vector<SPItem*> const &list,Geom::Point const &p, bool take_insensitive)
+{
+    g_return_val_if_fail(group, NULL);
+    SPItem *bottomMost = nullptr;
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gdouble delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
+
+    for (auto& o: group->children) {
+        if (bottomMost) {
+            break;
+        }
+        if (SP_IS_ITEM(&o)) {
+            SPItem *item = SP_ITEM(&o);
+            Inkscape::DrawingItem *arenaitem = item->get_arenaitem(dkey);
+
+            if (arenaitem) {
+                arenaitem->drawing().update();
+            }
+
+            if (arenaitem && arenaitem->pick(p, delta, 1) != nullptr
+                && (take_insensitive || item->isVisibleAndUnlocked(dkey))) {
+                if (find(list.begin(), list.end(), item) != list.end()) {
+                    bottomMost = item;
+                }
+            }
+
+            if (!bottomMost && SP_IS_GROUP(&o)) {
+                // return null if not found:
+                bottomMost = getItemFromListAtPointBottom(dkey, SP_GROUP(&o), list, p, take_insensitive);
+            }
+        }
+    }
+    return bottomMost;
+}
+
+/**
+Turn the SVG DOM into a flat list of nodes that can be searched from top-down.
+The list can be persisted, which improves "find at multiple points" speed.
+*/
+// TODO: study add `gboolean with_groups = false` as parameter.
+void SPDocument::build_flat_item_list(unsigned int dkey, SPGroup *group, gboolean into_groups) const
+{
+    for (auto& o: group->children) {
+        if (!SP_IS_ITEM(&o)) {
+            continue;
+        }
+
+        if (SP_IS_GROUP(&o) && (SP_GROUP(&o)->effectiveLayerMode(dkey) == SPGroup::LAYER || into_groups)) {
+            build_flat_item_list(dkey, SP_GROUP(&o), into_groups);
+        } else {
+            SPItem *child = SP_ITEM(&o);
+            if (child->isVisibleAndUnlocked(dkey)) {
+                _node_cache.push_front(child);
+            }
+        }
+    }
+}
+
+/**
+Returns the items from the descendants of group (recursively) which are at the
+point p, or NULL if none. Honors into_groups on whether to recurse into non-layer
+groups or not. Honors take_insensitive on whether to return insensitive items.
+If upto != NULL, then if item upto is encountered (at any level), stops searching
+upwards in z-order and returns what it has found so far (i.e. the found items are
+guaranteed to be lower than upto). Requires a list of nodes built by build_flat_item_list.
+If items_count > 0, it'll return the topmost (in z-order) items_count items.
+ */
+static std::vector<SPItem*> find_items_at_point(std::deque<SPItem*> *nodes, unsigned int dkey,
+                                                 Geom::Point const &p, int items_count=0, SPItem* upto=nullptr)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gdouble delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
+
+    SPItem *child;
+    std::vector<SPItem*> result;
+    bool seen_upto = (!upto);
+    for (auto node : *nodes) {
+        child = node;
+        if (!seen_upto){
+            if(child == upto)
+                seen_upto = true;
+            continue;
+        }
+        Inkscape::DrawingItem *arenaitem = child->get_arenaitem(dkey);
+        if (arenaitem) {
+            arenaitem->drawing().update();
+            if (arenaitem->pick(p, delta, 1) != nullptr) {
+                result.push_back(child);
+                if (--items_count == 0) {
+                    break;
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static SPItem *find_item_at_point(std::deque<SPItem*> *nodes, unsigned int dkey, Geom::Point const &p, SPItem* upto=nullptr)
+{
+    auto items = find_items_at_point(nodes, dkey, p, 1, upto);
+    if (items.empty()) {
+        return nullptr;
+    }
+    return items.back();
+}
+
+/**
+Returns the topmost non-layer group from the descendants of group which is at point
+p, or NULL if none. Recurses into layers but not into groups.
+ */
+static SPItem *find_group_at_point(unsigned int dkey, SPGroup *group, Geom::Point const &p)
+{
+    SPItem *seen = nullptr;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gdouble delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
+
+    for (auto& o: group->children) {
+        if (!SP_IS_ITEM(&o)) {
+            continue;
+        }
+        if (SP_IS_GROUP(&o) && SP_GROUP(&o)->effectiveLayerMode(dkey) == SPGroup::LAYER) {
+            SPItem *newseen = find_group_at_point(dkey, SP_GROUP(&o), p);
+            if (newseen) {
+                seen = newseen;
+            }
+        }
+        if (SP_IS_GROUP(&o) && SP_GROUP(&o)->effectiveLayerMode(dkey) != SPGroup::LAYER ) {
+            SPItem *child = SP_ITEM(&o);
+            Inkscape::DrawingItem *arenaitem = child->get_arenaitem(dkey);
+            if (arenaitem) {
+                arenaitem->drawing().update();
+            }
+
+            // seen remembers the last (topmost) of groups pickable at this point
+            if (arenaitem && arenaitem->pick(p, delta, 1) != nullptr) {
+                seen = child;
+            }
+        }
+    }
+    return seen;
+}
+
+
+/**
+ * Return list of items, contained in box
+ *
+ * @param box area to find items, in document coordinates
+ */
+
+std::vector<SPItem*> SPDocument::getItemsInBox(unsigned int dkey, Geom::Rect const &box, bool take_hidden, bool take_insensitive, bool take_groups, bool enter_groups) const
+{
+    std::vector<SPItem*> x;
+    return find_items_in_area(x, this->root, dkey, box, is_within, take_hidden, take_insensitive, take_groups, enter_groups);
+}
+
+/**
+ * Get items whose bounding box overlaps with given area.
+ * @param dkey desktop view in use
+ * @param box area to find items, in document coordinates
+ * @param take_hidden get hidden items
+ * @param take_insensitive get insensitive items
+ * @param take_groups get also the groups
+ * @param enter_groups get items inside groups
+ * @return Return list of items, that the parts of the item contained in box
+ */
+
+std::vector<SPItem*> SPDocument::getItemsPartiallyInBox(unsigned int dkey, Geom::Rect const &box, bool take_hidden, bool take_insensitive, bool take_groups, bool enter_groups) const
+{
+    std::vector<SPItem*> x;
+    return find_items_in_area(x, this->root, dkey, box, overlaps, take_hidden, take_insensitive, take_groups, enter_groups);
+}
+
+std::vector<SPItem*> SPDocument::getItemsAtPoints(unsigned const key, std::vector<Geom::Point> points, bool all_layers, bool topmost_only, size_t limit) const
+{
+    std::vector<SPItem*> result;
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+    // When picking along the path, we don't want small objects close together
+    // (such as hatching strokes) to obscure each other by their deltas,
+    // so we temporarily set delta to a small value
+    gdouble saved_delta = prefs->getDouble("/options/cursortolerance/value", 1.0);
+    prefs->setDouble("/options/cursortolerance/value", 0.25);
+
+    // Cache a flattened SVG DOM to speed up selection.
+    if(!_node_cache_valid){
+        _node_cache.clear();
+        build_flat_item_list(key, this->root, true);
+        _node_cache_valid=true;
+    }
+    SPObject *current_layer = nullptr;
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+    if(desktop){
+        current_layer = desktop->layerManager().currentLayer();
+    }
+    size_t item_counter = 0;
+    for(int i = points.size()-1;i>=0; i--) {
+        std::vector<SPItem*> items = find_items_at_point(&_node_cache, key, points[i], topmost_only);
+        for (SPItem *item : items) {
+            if (item && result.end()==find(result.begin(), result.end(), item))
+                if(all_layers || (desktop && desktop->layerManager().layerForObject(item) == current_layer)){
+                    result.push_back(item);
+                    item_counter++;
+                    //limit 0 = no limit
+                    if(item_counter == limit){
+                        prefs->setDouble("/options/cursortolerance/value", saved_delta);
+                        return result;
+                    }
+                }
+        }
+    }
+
+    // and now we restore it back
+    prefs->setDouble("/options/cursortolerance/value", saved_delta);
+
+    return result;
+}
+
+SPItem *SPDocument::getItemAtPoint( unsigned const key, Geom::Point const &p,
+                                    bool const into_groups, SPItem *upto) const
+{
+    // Build a flattened SVG DOM for find_item_at_point.
+    std::deque<SPItem*> bak(_node_cache);
+    if(!into_groups){
+        _node_cache.clear();
+        build_flat_item_list(key, this->root, into_groups);
+    }
+    if(!_node_cache_valid && into_groups){
+        _node_cache.clear();
+        build_flat_item_list(key, this->root, true);
+        _node_cache_valid=true;
+    }
+
+    SPItem *res = find_item_at_point(&_node_cache, key, p, upto);
+    if(!into_groups)
+        _node_cache = bak;
+    return res;
+}
+
+SPItem *SPDocument::getGroupAtPoint(unsigned int key, Geom::Point const &p) const
+{
+    return find_group_at_point(key, this->root, p);
+}
+
+// Resource management
+
+bool SPDocument::addResource(gchar const *key, SPObject *object)
+{
+    g_return_val_if_fail(key != nullptr, false);
+    g_return_val_if_fail(*key != '\0', false);
+    g_return_val_if_fail(object != nullptr, false);
+    g_return_val_if_fail(SP_IS_OBJECT(object), false);
+
+    bool result = false;
+
+    if ( !object->cloned ) {
+        std::vector<SPObject *> rlist = resources[key];
+        g_return_val_if_fail(std::find(rlist.begin(),rlist.end(),object) == rlist.end(), false);
+        resources[key].insert(resources[key].begin(),object);
+
+        GQuark q = g_quark_from_string(key);
+
+        /*in general, do not send signal if the object has no id (yet),
+        it means the object is not completely built.
+        (happens when pasting swatches across documents, cf bug 1495106)
+        [this check should be more generally presend on emit() calls since
+        the backtrace is unusable with crashed from this cause]
+        */
+        if(object->getId() || dynamic_cast<SPGroup*>(object) || dynamic_cast<SPPage*>(object) )
+            resources_changed_signals[q].emit();
+
+        result = true;
+    }
+
+    return result;
+}
+
+bool SPDocument::removeResource(gchar const *key, SPObject *object)
+{
+    g_return_val_if_fail(key != nullptr, false);
+    g_return_val_if_fail(*key != '\0', false);
+    g_return_val_if_fail(object != nullptr, false);
+    g_return_val_if_fail(SP_IS_OBJECT(object), false);
+
+    bool result = false;
+
+    if ( !object->cloned ) {
+        std::vector<SPObject *> rlist = resources[key];
+        g_return_val_if_fail(!rlist.empty(), false);
+        std::vector<SPObject*>::iterator it = std::find(resources[key].begin(),resources[key].end(),object);
+        g_return_val_if_fail(it != rlist.end(), false);
+        resources[key].erase(it);
+
+        GQuark q = g_quark_from_string(key);
+        resources_changed_signals[q].emit();
+
+        result = true;
+    }
+
+    return result;
+}
+
+std::vector<SPObject *> const SPDocument::getResourceList(gchar const *key)
+{
+    std::vector<SPObject *> emptyset;
+    g_return_val_if_fail(key != nullptr, emptyset);
+    g_return_val_if_fail(*key != '\0', emptyset);
+
+    return resources[key];
+}
+
+/* Helpers */
+
+static unsigned int count_objects_recursive(SPObject *obj, unsigned int count)
+{
+    count++; // obj itself
+
+    for (auto& i: obj->children) {
+        count = count_objects_recursive(&i, count);
+    }
+
+    return count;
+}
+
+/**
+ * Count the number of objects in a given document recursively using the count_objects_recursive helper function
+ *
+ * @param[in] document Pointer to the document for counting objects
+ * @return Number of objects in the document
+ */
+static unsigned int objects_in_document(SPDocument *document)
+{
+    return count_objects_recursive(document->getRoot(), 0);
+}
+
+/**
+ * Remove unused definitions etc. recursively from an object and its siblings
+ *
+ * @param[inout] obj Object which shall be "cleaned"
+ */
+static void vacuum_document_recursive(SPObject *obj)
+{
+    if (SP_IS_DEFS(obj)) {
+        for (auto& def: obj->children) {
+            // fixme: some inkscape-internal nodes in the future might not be collectable
+            def.requestOrphanCollection();
+        }
+    } else {
+        for (auto& i: obj->children) {
+            vacuum_document_recursive(&i);
+        }
+    }
+}
+
+/**
+ * Remove unused definitions etc. recursively from an entire document.
+ *
+ * @return Number of removed objects
+ */
+unsigned int SPDocument::vacuumDocument()
+{
+    unsigned int start = objects_in_document(this);
+    unsigned int end;
+    unsigned int newend = start;
+
+    unsigned int iterations = 0;
+
+    do {
+        end = newend;
+
+        vacuum_document_recursive(root);
+        this->collectOrphans();
+        iterations++;
+
+        newend = objects_in_document(this);
+
+    } while (iterations < 100 && newend < end);
+    // We stop if vacuum_document_recursive doesn't remove any more objects or after 100 iterations, whichever occurs first.
+
+    return start - newend;
+}
+
+/**
+ * Indicate to the user if the document has been modified since the last save by displaying a "*" in front of the name of the file in the window title.
+ *
+ * @param[in] modified True if the document has been modified.
+ */
+void SPDocument::setModifiedSinceSave(bool modified) {
+    this->modified_since_save = modified;
+    this->modified_since_autosave = modified;
+    if (SP_ACTIVE_DESKTOP) {
+        InkscapeWindow *window = SP_ACTIVE_DESKTOP->getInkscapeWindow();
+        if (window) { // during load, SP_ACTIVE_DESKTOP may be !nullptr, but parent might still be nullptr
+            SPDesktopWidget *dtw = window->get_desktop_widget();
+            dtw->updateTitle( this->getDocumentName() );
+        }
+    }
+}
+
+
+/**
+ * Paste SVG defs from the document retrieved from the clipboard or imported document into the active document.
+ * @param clipdoc The document to paste.
+ * @pre @c clipdoc != NULL and pasting into the active document is possible.
+ */
+void SPDocument::importDefs(SPDocument *source)
+{
+    Inkscape::XML::Node *root = source->getReprRoot();
+    Inkscape::XML::Node *target_defs = this->getDefs()->getRepr();
+    std::vector<Inkscape::XML::Node const *> defsNodes = sp_repr_lookup_name_many(root, "svg:defs");
+
+    prevent_id_clashes(source, this);
+
+    for (auto & defsNode : defsNodes) {
+       _importDefsNode(source, const_cast<Inkscape::XML::Node *>(defsNode), target_defs);
+    }
+}
+
+void SPDocument::_importDefsNode(SPDocument *source, Inkscape::XML::Node *defs, Inkscape::XML::Node *target_defs)
+{
+    int stagger=0;
+
+    /*  Note, "clipboard" throughout the comments means "the document that is either the clipboard
+        or an imported document", as importDefs is called in both contexts.
+
+        The order of the records in the clipboard is unpredictable and there may be both
+        forward and backwards references to other records within it.  There may be definitions in
+        the clipboard that duplicate definitions in the present document OR that duplicate other
+        definitions in the clipboard.  (Inkscape will not have created these, but they may be read
+        in from other SVG sources.)
+
+        There are 3 passes to clean this up:
+
+        In the first find and mark definitions in the clipboard that are duplicates of those in the
+        present document.  Change the ID to "RESERVED_FOR_INKSCAPE_DUPLICATE_DEF_XXXXXXXXX".
+        (Inkscape will not reuse an ID, and the XXXXXXXXX keeps it from automatically creating new ones.)
+        References in the clipboard to the old clipboard name are converted to the name used
+        in the current document.
+
+        In the second find and mark definitions in the clipboard that are duplicates of earlier
+        definitions in the clipbard.  Unfortunately this is O(n^2) and could be very slow for a large
+        SVG with thousands of definitions.  As before, references are adjusted to reflect the name
+        going forward.
+
+        In the final cycle copy over those records not marked with that ID.
+
+        If an SVG file uses the special ID it will cause problems!
+
+        If this function is called because of the paste of a true clipboard the caller will have passed in a
+        COPY of the clipboard items.  That is good, because this routine modifies that document.  If the calling
+        behavior ever changes, so that the same document is passed in on multiple pastes, this routine will break
+        as in the following example:
+        1.  Paste clipboard containing B same as A into document containing A.  Result, B is dropped
+        and all references to it will point to A.
+        2.  Paste same clipboard into a new document.  It will not contain A, so there will be unsatisfied
+        references in that window.
+    */
+
+    std::string DuplicateDefString = "RESERVED_FOR_INKSCAPE_DUPLICATE_DEF";
+
+    /* First pass: remove duplicates in clipboard of definitions in document */
+    for (Inkscape::XML::Node *def = defs->firstChild() ; def ; def = def->next()) {
+        if(def->type() != Inkscape::XML::NodeType::ELEMENT_NODE)continue;
+        /* If this  clipboard has been pasted into one document, and is now being pasted into another,
+        or pasted again into the same, it will already have been processed.  If we detect that then
+        skip the rest of this pass. */
+        Glib::ustring defid = def->attribute("id");
+        if( defid.find( DuplicateDefString ) != Glib::ustring::npos )break;
+
+        SPObject *src = source->getObjectByRepr(def);
+
+        // Prevent duplicates of solid swatches by checking if equivalent swatch already exists
+        SPGradient *s_gr = dynamic_cast<SPGradient *>(src);
+        LivePathEffectObject *s_lpeobj = dynamic_cast<LivePathEffectObject *>(src);
+        if (src && (s_gr || s_lpeobj)) {
+            for (auto& trg: getDefs()->children) {
+                SPGradient *t_gr = dynamic_cast<SPGradient *>(&trg);
+                if (src != &trg && s_gr && t_gr) {
+                    if (s_gr->isEquivalent(t_gr)) {
+                        // Change object references to the existing equivalent gradient
+                        Glib::ustring newid = trg.getId();
+                        if (newid != defid) { // id could be the same if it is a second paste into the same document
+                            change_def_references(src, &trg);
+                        }
+                        gchar *longid = g_strdup_printf("%s_%9.9d", DuplicateDefString.c_str(), stagger++);
+                        def->setAttribute("id", longid);
+                        g_free(longid);
+                        // do NOT break here, there could be more than 1 duplicate!
+                    }
+                }
+                LivePathEffectObject *t_lpeobj = dynamic_cast<LivePathEffectObject *>(&trg);
+                if (src != &trg && s_lpeobj && t_lpeobj) {
+                    if (t_lpeobj->is_similar(s_lpeobj)) {
+                        // Change object references to the existing equivalent gradient
+                        Glib::ustring newid = trg.getId();
+                        if (newid != defid) { // id could be the same if it is a second paste into the same document
+                            change_def_references(src, &trg);
+                        }
+                        gchar *longid = g_strdup_printf("%s_%9.9d", DuplicateDefString.c_str(), stagger++);
+                        def->setAttribute("id", longid);
+                        g_free(longid);
+                        // do NOT break here, there could be more than 1 duplicate!
+                    }
+                }
+            }
+        }
+    }
+
+    /* Second pass: remove duplicates in clipboard of earlier definitions in clipboard */
+    for (Inkscape::XML::Node *def = defs->firstChild() ; def ; def = def->next()) {
+        if(def->type() != Inkscape::XML::NodeType::ELEMENT_NODE)continue;
+        Glib::ustring defid = def->attribute("id");
+        if( defid.find( DuplicateDefString ) != Glib::ustring::npos )continue; // this one already handled
+        SPObject *src = source->getObjectByRepr(def);
+        LivePathEffectObject *s_lpeobj = dynamic_cast<LivePathEffectObject *>(src);
+        SPGradient *s_gr = dynamic_cast<SPGradient *>(src);
+        if (src && (s_gr || s_lpeobj)) {
+            for (Inkscape::XML::Node *laterDef = def->next() ; laterDef ; laterDef = laterDef->next()) {
+                SPObject *trg = source->getObjectByRepr(laterDef);
+                SPGradient *t_gr = dynamic_cast<SPGradient *>(trg);
+                if (trg && (src != trg) && s_gr && t_gr) {
+                    Glib::ustring newid = trg->getId();
+                    if (newid.find(DuplicateDefString) != Glib::ustring::npos)
+                        continue; // this one already handled
+                    if (t_gr && s_gr->isEquivalent(t_gr)) {
+                        // Change object references to the existing equivalent gradient
+                        // two id's in the clipboard should never be the same, so always change references
+                        change_def_references(trg, src);
+                        gchar *longid = g_strdup_printf("%s_%9.9d", DuplicateDefString.c_str(), stagger++);
+                        laterDef->setAttribute("id", longid);
+                        g_free(longid);
+                        // do NOT break here, there could be more than 1 duplicate!
+                    }
+                }
+                LivePathEffectObject *t_lpeobj = dynamic_cast<LivePathEffectObject *>(trg);
+                if (trg && (src != trg) && s_lpeobj && t_lpeobj) {
+                    Glib::ustring newid = trg->getId();
+                    if (newid.find(DuplicateDefString) != Glib::ustring::npos)
+                        continue; // this one already handled
+                    if (t_lpeobj->is_similar(s_lpeobj)) {
+                        // Change object references to the existing equivalent gradient
+                        // two id's in the clipboard should never be the same, so always change references
+                        change_def_references(trg, src);
+                        gchar *longid = g_strdup_printf("%s_%9.9d", DuplicateDefString.c_str(), stagger++);
+                        laterDef->setAttribute("id", longid);
+                        g_free(longid);
+                        // do NOT break here, there could be more than 1 duplicate!
+                    }
+                }
+            }
+        }
+    }
+
+    /* Final pass: copy over those parts which are not duplicates  */
+    for (Inkscape::XML::Node *def = defs->firstChild() ; def ; def = def->next()) {
+        if(def->type() != Inkscape::XML::NodeType::ELEMENT_NODE)continue;
+
+        /* Ignore duplicate defs marked in the first pass */
+        Glib::ustring defid = def->attribute("id");
+        if( defid.find( DuplicateDefString ) != Glib::ustring::npos )continue;
+
+        bool duplicate = false;
+        SPObject *src = source->getObjectByRepr(def);
+
+        // Prevent duplication of symbols... could be more clever.
+        // The tag "_inkscape_duplicate" is added to "id" by ClipboardManagerImpl::copySymbol().
+        // We assume that symbols are in defs section (not required by SVG spec).
+        if (src && SP_IS_SYMBOL(src)) {
+
+            Glib::ustring id = src->getRepr()->attribute("id");
+            size_t pos = id.find( "_inkscape_duplicate" );
+            if( pos != Glib::ustring::npos ) {
+
+                // This is our symbol, now get rid of tag
+                id.erase( pos );
+
+                // Check that it really is a duplicate
+                for (auto& trg: getDefs()->children) {
+                    if (SP_IS_SYMBOL(&trg) && src != &trg) {
+                        std::string id2 = trg.getRepr()->attribute("id");
+
+                        if( !id.compare( id2 ) ) {
+                            duplicate = true;
+                            break;
+                        }
+                    }
+                }
+                if ( !duplicate ) {
+                    src->setAttribute("id", id);
+                }
+            }
+        }
+
+        if (!duplicate) {
+            Inkscape::XML::Node * dup = def->duplicate(this->getReprDoc());
+            target_defs->appendChild(dup);
+            Inkscape::GC::release(dup);
+        }
+    }
+}
+
+// Signals ------------------------------
+
+void
+SPDocument::addUndoObserver(Inkscape::UndoStackObserver& observer)
+{
+    this->undoStackObservers.add(observer);
+}
+
+void
+SPDocument::removeUndoObserver(Inkscape::UndoStackObserver& observer)
+{
+    this->undoStackObservers.remove(observer);
+}
+
+sigc::connection SPDocument::connectDestroy(sigc::signal<void>::slot_type slot)
+{
+    return destroySignal.connect(slot);
+}
+
+sigc::connection SPDocument::connectModified(SPDocument::ModifiedSignal::slot_type slot)
+{
+    return modified_signal.connect(slot);
+}
+
+sigc::connection SPDocument::connectFilenameSet(SPDocument::FilenameSetSignal::slot_type slot)
+{
+    return filename_set_signal.connect(slot);
+}
+
+sigc::connection SPDocument::connectCommit(SPDocument::CommitSignal::slot_type slot)
+{
+    return commit_signal.connect(slot);
+}
+
+sigc::connection SPDocument::connectBeforeCommit(SPDocument::BeforeCommitSignal::slot_type slot)
+{
+    return before_commit_signal.connect(slot);
+}
+
+sigc::connection SPDocument::connectIdChanged(gchar const *id,
+                                              SPDocument::IDChangedSignal::slot_type slot)
+{
+    return id_changed_signals[g_quark_from_string(id)].connect(slot);
+}
+
+sigc::connection SPDocument::connectResourcesChanged(gchar const *key,
+                                                     SPDocument::ResourcesChangedSignal::slot_type slot)
+{
+    GQuark q = g_quark_from_string(key);
+    return resources_changed_signals[q].connect(slot);
+}
+
+sigc::connection
+SPDocument::connectReconstructionStart(SPDocument::ReconstructionStart::slot_type slot)
+{
+    return _reconstruction_start_signal.connect(slot);
+}
+
+sigc::connection
+SPDocument::connectReconstructionFinish(SPDocument::ReconstructionFinish::slot_type  slot)
+{
+    return _reconstruction_finish_signal.connect(slot);
+}
+
+void SPDocument::_emitModified() {
+    static guint const flags = SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG | SP_OBJECT_PARENT_MODIFIED_FLAG;
+    root->emitModified(0);
+    modified_signal.emit(flags);
+    _node_cache_valid=false;
+}
+
+void
+SPDocument::emitReconstructionStart()
+{
+    // printf("Starting Reconstruction\n");
+    _reconstruction_start_signal.emit();
+}
+
+void
+SPDocument::emitReconstructionFinish()
+{
+    // printf("Finishing Reconstruction\n");
+    _reconstruction_finish_signal.emit();
+    // indicates that gradients are reloaded (to rebuild the Auto palette)
+    resources_changed_signals[g_quark_from_string("gradient")].emit();
+    resources_changed_signals[g_quark_from_string("filter")].emit();
+
+/**
+    // Reference to the old persp3d object is invalid after reconstruction.
+    initialize_current_persp3d();
+**/
+}
+
+void SPDocument::set_reference_document(SPDocument* document) {
+    _ref_document = document;
+}
+
+SPDocument* SPDocument::get_reference_document() {
+    return _ref_document;
+}
+
+SPDocument::install_reference_document::install_reference_document(SPDocument* inject_into, SPDocument* reference) {
+    g_assert(inject_into);
+    _parent = inject_into;
+    _parent->set_reference_document(reference);
+}
+
+SPDocument::install_reference_document::~install_reference_document() {
+    _parent->set_reference_document(nullptr);
+}
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :