~inkscape.dev/inkscape/trunk

/*

 * 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, 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

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <string>

#include <cstring>

#include <2geom/transforms.h>

#include "widgets/desktop-widget.h"

#include "desktop.h"

#include "dir-util.h"

#include "display/drawing-item.h"

#include "document-private.h"

#include "document-undo.h"

#include "id-clash.h"

#include "inkscape.h"

#include "inkscape-version.h"

#include "libavoid/router.h"

#include "persp3d.h"

#include "preferences.h"

#include "profile-manager.h"

#include "rdf.h"

#include "sp-factory.h"

#include "sp-item-group.h"

#include "sp-namedview.h"

#include "sp-symbol.h"

#include "transf_mat_3x4.h"

#include "util/units.h"

#include "xml/repr.h"

#include "xml/rebase-hrefs.h"

#include "libcroco/cr-cascade.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)

static gint sp_document_idle_handler(gpointer data);

static gint sp_document_rerouting_handler(gpointer data);

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),

    modified_since_save(FALSE),

    rdoc(NULL),

    rroot(NULL),

    root(NULL),

    style_cascade(cr_cascade_new(NULL, NULL, NULL)),

    uri(NULL),

    base(NULL),

    name(NULL),

    priv(NULL), // reset in ctor

    actionkey(),

    modified_id(0),

    rerouting_handler_id(0),

    profileManager(NULL), // deferred until after other initialization

    router(new Avoid::Router(Avoid::PolyLineRouting|Avoid::OrthogonalRouting)),

    _collection_queue(NULL),

    oldSignalsConnected(false),

    current_persp3d(NULL),

    current_persp3d_impl(NULL),

    _parent_document(NULL)

{

    // Penalise libavoid for choosing paths with needless extra segments.

    // This results in much better looking orthogonal connector paths.

    router->setRoutingPenalty(Avoid::segmentPenalty);

    SPDocumentPrivate *p = new SPDocumentPrivate();

    p->serial = next_serial++;

    p->iddef = g_hash_table_new(g_direct_hash, g_direct_equal);

    p->reprdef = g_hash_table_new(g_direct_hash, g_direct_equal);

    p->resources = g_hash_table_new(g_str_hash, g_str_equal);

    p->sensitive = false;

    p->partial = NULL;

    p->history_size = 0;

    p->undo = NULL;

    p->redo = NULL;

    p->seeking = false;

    priv = p;

    // Once things are set, hook in the manager

    profileManager = new Inkscape::ProfileManager(this);

    // XXX only for testing!

    priv->undoStackObservers.add(p->console_output_undo_observer);

}

SPDocument::~SPDocument() {

    priv->destroySignal.emit();

    // kill/unhook this first

    if ( profileManager ) {

        delete profileManager;

        profileManager = 0;

    }

    if (router) {

        delete router;

        router = NULL;

    }

    if (oldSignalsConnected) {

        priv->selChangeConnection.disconnect();

        priv->desktopActivatedConnection.disconnect();

    } else {

        _selection_changed_connection.disconnect();

        _desktop_activated_connection.disconnect();

    }

    if (priv) {

        if (priv->partial) {

            sp_repr_free_log(priv->partial);

            priv->partial = NULL;

        }

        DocumentUndo::clearRedo(this);

        DocumentUndo::clearUndo(this);

        if (root) {

            root->releaseReferences();

            sp_object_unref(root);

            root = NULL;

        }

        if (priv->iddef) g_hash_table_destroy(priv->iddef);

        if (priv->reprdef) g_hash_table_destroy(priv->reprdef);

        if (rdoc) Inkscape::GC::release(rdoc);

        /* Free resources */

        g_hash_table_foreach_remove(priv->resources, sp_document_resource_list_free, this);

        g_hash_table_destroy(priv->resources);

        delete priv;

        priv = NULL;

    }

    cr_cascade_unref(style_cascade);

    style_cascade = NULL;

    if (name) {

        g_free(name);

        name = NULL;

    }

    if (base) {

        g_free(base);

        base = NULL;

    }

    if (uri) {

        g_free(uri);

        uri = NULL;

    }

    if (modified_id) {

        g_source_remove(modified_id);

        modified_id = 0;

    }

    if (rerouting_handler_id) {

        g_source_remove(rerouting_handler_id);

        rerouting_handler_id = 0;

    }

    if (keepalive) {

        inkscape_unref(INKSCAPE);

        keepalive = FALSE;

    }

    if (this->current_persp3d_impl) 

        delete this->current_persp3d_impl;

    this->current_persp3d_impl = NULL;

    // This is at the end of the destructor, because preceding code adds new orphans to the queue

    collectOrphans();

}

sigc::connection SPDocument::connectDestroy(sigc::signal<void>::slot_type slot)

{

    return priv->destroySignal.connect(slot);

}

SPDefs *SPDocument::getDefs()

{

    if (!root) {

        return NULL;

    }

    return root->defs;

}

Persp3D *SPDocument::getCurrentPersp3D() {

    // Check if current_persp3d is still valid

    std::vector<Persp3D*> plist;

    getPerspectivesInDefs(plist);

    for (unsigned int i = 0; i < plist.size(); ++i) {

        if (current_persp3d == plist[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;

}

Persp3DImpl *SPDocument::getCurrentPersp3DImpl() {

    return current_persp3d_impl;

}

void SPDocument::setCurrentPersp3D(Persp3D * const persp) {

    current_persp3d = persp;

    //current_persp3d_impl = persp->perspective_impl;

}

void SPDocument::getPerspectivesInDefs(std::vector<Persp3D*> &list) const

{

    for (SPObject *i = root->defs->firstChild(); i; i = i->getNext() ) {

        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);

    }

}

**/

unsigned long SPDocument::serial() const {

    return priv->serial;

}

void SPDocument::queueForOrphanCollection(SPObject *object) {

    g_return_if_fail(object != NULL);

    g_return_if_fail(object->document == this);

    sp_object_ref(object, NULL);

    _collection_queue = g_slist_prepend(_collection_queue, object);

}

void SPDocument::collectOrphans() {

    while (_collection_queue) {

        GSList *objects=_collection_queue;

        _collection_queue = NULL;

        for ( GSList *iter=objects ; iter ; iter = iter->next ) {

            SPObject *object=reinterpret_cast<SPObject *>(iter->data);

            object->collectOrphan();

            sp_object_unref(object, NULL);

        }

        g_slist_free(objects);

    }

}

void SPDocument::reset_key (void */*dummy*/)

{

    actionkey.clear();

}

SPDocument *SPDocument::createDoc(Inkscape::XML::Document *rdoc,

                                  gchar const *uri,

                                  gchar const *base,

                                  gchar const *name,

                                  unsigned int keepalive,

                                  SPDocument *parent)

{

    SPDocument *document = new SPDocument();

    Inkscape::Preferences *prefs = Inkscape::Preferences::get();

    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->uri){

        g_free(document->uri);

        document->uri = 0;

    }

    if (document->base){

        g_free(document->base);

        document->base = 0;

    }

    if (document->name){

        g_free(document->name);

        document->name = 0;

    }

#ifndef WIN32

    document->uri = prepend_current_dir_if_relative(uri);

#else

    // FIXME: it may be that prepend_current_dir_if_relative works OK on windows too, test!

    document->uri = uri? g_strdup(uri) : 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 (base) {

        document->base = g_strdup(base);

    } else {

        document->base = NULL;

    }

    document->name = g_strdup(name);

    // Create SPRoot element

    const std::string typeString = NodeTraits::get_type_string(*rroot);

    SPObject* rootObj = SPFactory::instance().createObject(typeString);

    document->root = dynamic_cast<SPRoot*>(rootObj);

    if (document->root == 0) {

    	// 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);

    /* fixme: Not sure about this, but lets assume ::build updates */

    rroot->setAttribute("inkscape:version", Inkscape::version_string);

    /* fixme: Again, I moved these here to allow version determining in ::build (Lauris) */

    /* Eliminate obsolete sodipodi:docbase, for privacy reasons */

    rroot->setAttribute("sodipodi:docbase", NULL);

    /* Eliminate any claim to adhere to a profile, as we don't try to */

    rroot->setAttribute("baseProfile", NULL);

    // creating namedview

    if (!sp_item_group_get_child_by_name(document->root, NULL, "sodipodi:namedview")) {

        // if there's none in the document already,

        Inkscape::XML::Node *rnew = NULL;

        rnew = rdoc->createElement("sodipodi:namedview");

        //rnew->setAttribute("id", "base");

        // Add namedview data from the preferences

        // we can't use getAllEntries because this could produce non-SVG doubles

        Glib::ustring pagecolor = prefs->getString("/template/base/pagecolor");

        if (!pagecolor.empty()) {

            rnew->setAttribute("pagecolor", pagecolor.data());

        }

        Glib::ustring bordercolor = prefs->getString("/template/base/bordercolor");

        if (!bordercolor.empty()) {

            rnew->setAttribute("bordercolor", bordercolor.data());

        }

        sp_repr_set_svg_double(rnew, "borderopacity",

            prefs->getDouble("/template/base/borderopacity", 1.0));

        sp_repr_set_svg_double(rnew, "objecttolerance",

            prefs->getDouble("/template/base/objecttolerance", 10.0));

        sp_repr_set_svg_double(rnew, "gridtolerance",

            prefs->getDouble("/template/base/gridtolerance", 10.0));

        sp_repr_set_svg_double(rnew, "guidetolerance",

            prefs->getDouble("/template/base/guidetolerance", 10.0));

        sp_repr_set_svg_double(rnew, "inkscape:pageopacity",

            prefs->getDouble("/template/base/inkscape:pageopacity", 0.0));

        sp_repr_set_int(rnew, "inkscape:pageshadow",

            prefs->getInt("/template/base/inkscape:pageshadow", 2));

        sp_repr_set_int(rnew, "inkscape:window-width",

            prefs->getInt("/template/base/inkscape:window-width", 640));

        sp_repr_set_int(rnew, "inkscape:window-height",

            prefs->getInt("/template/base/inkscape:window-height", 480));

        // insert into the document

        rroot->addChild(rnew, NULL);

        // clean up

        Inkscape::GC::release(rnew);

    }

    // Defs

    if (!document->root->defs) {

        Inkscape::XML::Node *r = rdoc->createElement("svg:defs");

        rroot->addChild(r, NULL);

        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->priv->selChangeConnection = INKSCAPE.signal_selection_changed.connect(

                sigc::hide(sigc::bind(

                sigc::ptr_fun(&DocumentUndo::resetKey), document)

    ));

    document->priv->desktopActivatedConnection = INKSCAPE.signal_activate_desktop.connect(

                sigc::hide(sigc::bind(

                sigc::ptr_fun(&DocumentUndo::resetKey), document)

    ));

    document->oldSignalsConnected = true;

    return document;

}

/**

 * Fetches a document and attaches it to the current document as a child href

 */

SPDocument *SPDocument::createChildDoc(std::string const &uri)

{

    SPDocument *parent = this;

    SPDocument *document = NULL;

    while(parent != NULL && parent->getURI() != NULL && document == NULL) {

        // Check myself and any parents int he chain

        if(uri == parent->getURI()) {

            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(uri == iter->getURI()) {

                document = &*iter;

                break;

            }

        }

        parent = parent->_parent_document;

    }

    // Load a fresh document from the svg source.

    if(!document) {

        const char *path = uri.c_str();

        document = createNewDoc(path, false, false, this);

    }

    return document;

}

/**

 * Fetches document from URI, or creates new, if NULL; public document

 * appears in document list.

 */

SPDocument *SPDocument::createNewDoc(gchar const *uri, unsigned int keepalive, bool make_new, SPDocument *parent)

{

    Inkscape::XML::Document *rdoc = NULL;

    gchar *base = NULL;

    gchar *name = NULL;

    if (uri) {

        Inkscape::XML::Node *rroot;

        gchar *s, *p;

        /* Try to fetch repr from file */

        rdoc = sp_repr_read_file(uri, SP_SVG_NS_URI);

        /* If file cannot be loaded, return NULL without warning */

        if (rdoc == NULL) return NULL;

        rroot = rdoc->root();

        /* If xml file is not svg, return NULL without warning */

        /* fixme: destroy document */

        if (strcmp(rroot->name(), "svg:svg") != 0) return NULL;

        s = g_strdup(uri);

        p = strrchr(s, '/');

        if (p) {

            name = g_strdup(p + 1);

            p[1] = '\0';

            base = g_strdup(s);

        } else {

            base = NULL;

            name = g_strdup(uri);

        }

        if (make_new) {

            base = NULL;

            uri = NULL;

            name = g_strdup_printf(_("New document %d"), ++doc_count);

        }

        g_free(s);

    } else {

        if (make_new) {

            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(name);

    SPDocument *doc = createDoc(rdoc, uri, base, name, keepalive, parent);

    g_free(base);

    g_free(name);

    return doc;

}

SPDocument *SPDocument::createNewDocFromMem(gchar const *buffer, gint length, unsigned int keepalive)

{

    SPDocument *doc = NULL;

    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 name = Glib::ustring::compose( _("Memory document %1"), ++doc_mem_count );

            doc = createDoc(rdoc, NULL, NULL, name.c_str(), keepalive, NULL);

        }

    }

    return doc;

}

SPDocument *SPDocument::doRef()

{

    Inkscape::GC::anchor(this);

    return this;

}

SPDocument *SPDocument::doUnref()

{

    Inkscape::GC::release(this);

    return NULL;

}

/// guaranteed not to return nullptr

Inkscape::Util::Unit const* SPDocument::getDisplayUnit() const

{

    SPNamedView const* nv = sp_document_namedview(this, NULL);

    return nv ? nv->getDisplayUnit() : unit_table.getUnit("px");

}

/// guaranteed not to return nullptr

// returns 'px' units as default, like legacy Inkscape

// THIS SHOULD NOT BE USED... INSTEAD USE DOCUMENT SCALE

Inkscape::Util::Unit const& SPDocument::getSVGUnit() const

{

    SPNamedView const* nv = sp_document_namedview(this, NULL);

    return nv ? nv->getSVGUnit() : *unit_table.getUnit("px");

}

/// Returns document scale as defined by width/height 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(). Also called in page-sizer.cpp)

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 = 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 = 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.left() + (root->width.value /  old_width_converted ) * root->viewBox.width(),