Merged hatch rendering code

(bzr r13611.1.8)

1 files changed, 616 insertions, 0 deletions

diff --git a/src/sp-hatch.cpp b/src/sp-hatch.cpp
new file mode 100644
index 000000000..cde6c86cb
--- /dev/null
+++ b/src/sp-hatch.cpp
@@ -0,0 +1,616 @@
+/** @file
+ * SVG <hatch> implementation
+ *//*
+ * Author:
+ *   Tomasz Boczkowski <penginsbacon@gmail.com>
+ *
+ * Copyright (C) 2014 Tomasz Boczkowski
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <cstring>
+#include <string>
+#include <2geom/transforms.h>
+#include <sigc++/functors/mem_fun.h>
+
+#include "svg/svg.h"
+#include "display/cairo-utils.h"
+#include "display/drawing-context.h"
+#include "display/drawing-surface.h"
+#include "display/drawing.h"
+#include "display/drawing-pattern.h"
+#include "attributes.h"
+#include "document-private.h"
+#include "uri.h"
+#include "style.h"
+#include "sp-hatch.h"
+#include "sp-hatch-path.h"
+#include "xml/repr.h"
+
+#include "sp-factory.h"
+
+namespace {
+SPObject* createHatch() {
+    return new SPHatch();
+}
+
+bool hatchRegistered = SPFactory::instance().registerObject("svg:hatch", createHatch);
+}
+
+SPHatch::SPHatch()
+        : SPPaintServer()
+{
+    this->ref = new SPHatchReference(this);
+    this->ref->changedSignal().connect(sigc::mem_fun(this, &SPHatch::_onRefChanged));
+
+    this->_hatchUnits = UNITS_OBJECTBOUNDINGBOX;
+    this->_hatchUnits_set = false;
+
+    this->_hatchContentUnits = UNITS_USERSPACEONUSE;
+    this->_hatchContentUnits_set = false;
+
+    this->_hatchTransform = Geom::identity();
+    this->_hatchTransform_set = false;
+
+    this->_x.unset();
+    this->_y.unset();
+    this->_pitch.unset();
+    this->_rotate.unset();
+}
+
+SPHatch::~SPHatch() {
+}
+
+void SPHatch::build(SPDocument* doc, Inkscape::XML::Node* repr) {
+    SPPaintServer::build(doc, repr);
+
+    this->readAttr("hatchUnits");
+    this->readAttr("hatchContentUnits");
+    this->readAttr("hatchTransform");
+    this->readAttr("x");
+    this->readAttr("y");
+    this->readAttr("pitch");
+    this->readAttr("rotate");
+    this->readAttr("xlink:href");
+
+    /* Register ourselves */
+    doc->addResource("hatch", this);
+}
+
+void SPHatch::release() {
+    if (this->document) {
+        // Unregister ourselves
+        this->document->removeResource("hatch", this);
+    }
+
+    std::vector<SPHatchPath *> children;
+    _children(children);
+    for (ViewIterator view_iter = _display.begin(); view_iter != _display.end(); view_iter++) {
+        for (ChildIterator child_iter = children.begin(); child_iter != children.end();
+                child_iter++) {
+            SPHatchPath *child = *child_iter;
+            child->hide(view_iter->key);
+        }
+        delete view_iter->arenaitem;
+        view_iter->arenaitem = NULL;
+    }
+
+    if (this->ref) {
+        this->_modified_connection.disconnect();
+        this->ref->detach();
+        delete this->ref;
+        this->ref = NULL;
+    }
+
+    SPPaintServer::release();
+}
+
+void SPHatch::child_added(Inkscape::XML::Node* child, Inkscape::XML::Node* ref) {
+    SPObject::child_added(child, ref);
+
+    SPHatchPath *path_child = SP_HATCH_PATH(this->document->getObjectByRepr(child));
+
+    if (path_child) {
+        for (ViewIterator iter = _display.begin(); iter != _display.end(); iter++) {
+            Inkscape::DrawingItem *ac = path_child->show(iter->arenaitem->drawing(), iter->key);
+
+            Geom::OptInterval strip_extents = _calculateStripExtents(iter->bbox);
+            path_child->setStripExtents(iter->key, strip_extents);
+            path_child->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+            if (ac) {
+                iter->arenaitem->prependChild(ac);
+            }
+        }
+    }
+    //FIXME: notify all hatches that refer to this child set
+}
+
+void SPHatch::set(unsigned int key, const gchar* value) {
+    switch (key) {
+    case SP_ATTR_HATCHUNITS:
+        if (value) {
+            if (!strcmp(value, "userSpaceOnUse")) {
+                this->_hatchUnits = UNITS_USERSPACEONUSE;
+            } else {
+                this->_hatchUnits = UNITS_OBJECTBOUNDINGBOX;
+            }
+
+            this->_hatchUnits_set = true;
+        } else {
+            this->_hatchUnits_set = false;
+        }
+
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_HATCHCONTENTUNITS:
+        if (value) {
+            if (!strcmp(value, "userSpaceOnUse")) {
+                this->_hatchContentUnits = UNITS_USERSPACEONUSE;
+            } else {
+                this->_hatchContentUnits = UNITS_OBJECTBOUNDINGBOX;
+            }
+
+            this->_hatchContentUnits_set = true;
+        } else {
+            this->_hatchContentUnits_set = false;
+        }
+
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_HATCHTRANSFORM: {
+        Geom::Affine t;
+
+        if (value && sp_svg_transform_read(value, &t)) {
+            this->_hatchTransform = t;
+            this->_hatchTransform_set = true;
+        } else {
+            this->_hatchTransform = Geom::identity();
+            this->_hatchTransform_set = false;
+        }
+
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+    }
+    case SP_ATTR_X:
+        this->_x.readOrUnset(value);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_Y:
+        this->_y.readOrUnset(value);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_PITCH:
+        this->_pitch.readOrUnset(value);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_ROTATE:
+        this->_rotate.readOrUnset(value);
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    case SP_ATTR_XLINK_HREF:
+        if (value && this->href == value) {
+            /* Href unchanged, do nothing. */
+        } else {
+            this->href.clear();
+
+            if (value) {
+                // First, set the href field; it's only used in the "unchanged" check above.
+                this->href = value;
+                // Now do the attaching, which emits the changed signal.
+                if (value) {
+                    try {
+                        this->ref->attach(Inkscape::URI(value));
+                    } catch (Inkscape::BadURIException &e) {
+                        g_warning("%s", e.what());
+                        this->ref->detach();
+                    }
+                } else {
+                    this->ref->detach();
+                }
+            }
+        }
+        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+        break;
+
+    default:
+        SPPaintServer::set(key, value);
+        break;
+    }
+}
+
+bool SPHatch::_hasHatchPatchChildren(SPHatch const *hatch) {
+    for (SPObject const *child = hatch->firstChild(); child; child = child->getNext() ) {
+        if (SP_IS_HATCH_PATH(child)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void SPHatch::_children(std::vector<SPHatchPath*>& l) {
+    SPHatch *src = chase_hrefs<SPHatch>(this, sigc::ptr_fun(&_hasHatchPatchChildren));
+
+    if (src) {
+        for (SPObject *child = src->firstChild(); child; child = child->getNext()) {
+            if (SP_IS_HATCH_PATH(child)) {
+                l.push_back(SP_HATCH_PATH(child));
+            }
+        }
+    }
+}
+
+void SPHatch::_children(std::vector<SPHatchPath const*>& l) const {
+    SPHatch const *src = chase_hrefs<SPHatch const>(this, sigc::ptr_fun(&_hasHatchPatchChildren));
+
+    if (src) {
+        for (SPObject const *child = src->firstChild(); child; child = child->getNext()) {
+            if (SP_IS_HATCH_PATH(child)) {
+                l.push_back(SP_HATCH_PATH(child));
+            }
+        }
+    }
+}
+
+/* TODO: ::remove_child and ::order_changed handles - see SPPattern */
+
+
+void SPHatch::update(SPCtx* ctx, unsigned int flags) {
+    typedef std::list<SPHatch::View>::iterator ViewIterator;
+
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+        flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    }
+
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
+
+    std::vector<SPHatchPath *> children;
+    _children(children);
+
+    for (ChildIterator iter = children.begin(); iter != children.end(); iter++) {
+        SPHatchPath* child = *iter;
+
+        sp_object_ref(child, NULL);
+
+        for (ViewIterator view_iter = _display.begin(); view_iter != _display.end(); view_iter++) {
+            Geom::OptInterval strip_extents = _calculateStripExtents(view_iter->bbox);
+            child->setStripExtents(view_iter->key, strip_extents);
+        }
+
+        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+
+            child->updateDisplay(ctx, flags);
+        }
+
+        sp_object_unref(child, NULL);
+    }
+
+    for (ViewIterator iter = _display.begin(); iter != _display.end(); iter++) {
+        _updateView(*iter);
+    }
+}
+
+void SPHatch::modified(unsigned int flags) {
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+        flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    }
+
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
+
+    std::vector<SPHatchPath *> children;
+    _children(children);
+
+    for (ChildIterator iter = children.begin(); iter != children.end(); iter++) {
+        SPObject *child = *iter;
+
+        sp_object_ref(child, NULL);
+
+        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+            child->emitModified(flags);
+        }
+
+        sp_object_unref(child, NULL);
+    }
+}
+
+void SPHatch::_onRefChanged(SPObject *old_ref, SPObject *ref) {
+    typedef std::list<SPHatch::View>::iterator ViewIterator;
+
+    if (old_ref) {
+        _modified_connection.disconnect();
+    }
+
+    if (SP_IS_HATCH(ref)) {
+        _modified_connection = ref->connectModified(sigc::mem_fun(this, &SPHatch::_onRefModified));
+    }
+
+    if (!_hasHatchPatchChildren(this)) {
+        SPHatch *old_shown = NULL;
+        SPHatch *new_shown = NULL;
+        std::vector<SPHatchPath *> old_children;
+        std::vector<SPHatchPath *> new_children;
+        if (SP_IS_HATCH(old_ref)) {
+            old_shown = SP_HATCH(old_ref)->rootHatch();
+            old_shown->_children(old_children);
+        }
+        if (SP_IS_HATCH(ref)) {
+            new_shown = SP_HATCH(ref)->rootHatch();
+            new_shown->_children(new_children);
+        }
+        if (old_shown != new_shown) {
+
+            for (ViewIterator iter = _display.begin(); iter != _display.end(); iter++) {
+                Geom::OptInterval extents = _calculateStripExtents(iter->bbox);
+
+                for (ChildIterator child_iter = old_children.begin(); child_iter != old_children.end(); child_iter++) {
+                    SPHatchPath *child = *child_iter;
+                    child->hide(iter->key);
+                }
+                for (ChildIterator child_iter = new_children.begin(); child_iter != new_children.end(); child_iter++) {
+                    SPHatchPath *child = *child_iter;
+                    Inkscape::DrawingItem *cai = child->show(iter->arenaitem->drawing(), iter->key);
+                    child->setStripExtents(iter->key, extents);
+                    child->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+                    if (cai) {
+                        iter->arenaitem->appendChild(cai);
+                    }
+
+                }
+            }
+        }
+    }
+
+    _onRefModified(ref, 0);
+}
+
+void SPHatch::_onRefModified(SPObject */*ref*/, guint /*flags*/) {
+    requestModified(SP_OBJECT_MODIFIED_FLAG);
+    // Conditional to avoid causing infinite loop if there's a cycle in the href chain.
+}
+
+
+SPHatch *SPHatch::rootHatch() {
+    SPHatch *src = chase_hrefs<SPHatch>(this, sigc::ptr_fun(&_hasHatchPatchChildren));
+    return src ? src : this; // document is broken, we can't get to root; but at least we can return pat which is supposedly a valid hatch
+}
+
+// Access functions that look up fields up the chain of referenced hatchs and return the first one which is set
+// FIXME: all of them must use chase_hrefs as children() and rootHatch()
+
+SPHatch::HatchUnits SPHatch::hatchUnits() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_hatchUnits_set)
+            return pat_i->_hatchUnits;
+    }
+    return _hatchUnits;
+}
+
+SPHatch::HatchUnits SPHatch::hatchContentUnits() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_hatchContentUnits_set)
+            return pat_i->_hatchContentUnits;
+    }
+    return _hatchContentUnits;
+}
+
+Geom::Affine const &SPHatch::hatchTransform() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_hatchTransform_set)
+            return pat_i->_hatchTransform;
+    }
+    return _hatchTransform;
+}
+
+gdouble SPHatch::x() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_x._set)
+            return pat_i->_x.computed;
+    }
+    return 0;
+}
+
+gdouble SPHatch::y() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_y._set)
+            return pat_i->_y.computed;
+    }
+    return 0;
+}
+
+gdouble SPHatch::pitch() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_pitch._set)
+            return pat_i->_pitch.computed;
+    }
+    return 0;
+}
+
+gdouble SPHatch::rotate() const {
+    for (SPHatch const *pat_i = this; pat_i != NULL;
+            pat_i = pat_i->ref ? pat_i->ref->getObject() : NULL) {
+        if (pat_i->_rotate._set)
+            return pat_i->_rotate.computed;
+    }
+    return 0;
+}
+
+bool SPHatch::isValid() const {
+    double strip_pitch = pitch();
+    if (strip_pitch <= 0) {
+        return false;
+    }
+
+    std::vector<SPHatchPath const *> children;
+    _children(children);
+    if (children.empty()) {
+        return false;
+    }
+    for (ConstChildIterator iter = children.begin(); iter != children.end(); iter++) {
+        SPHatchPath const *child = *iter;
+        if (!child->isValid()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+Inkscape::DrawingPattern *SPHatch::show(Inkscape::Drawing &drawing, unsigned int key) {
+    Inkscape::DrawingPattern *ai = new Inkscape::DrawingPattern(drawing);
+    //TODO: set some debug flag to see DrawingPattern
+    _display.push_front(View(ai, key));
+
+    std::vector<SPHatchPath *> children;
+    _children(children);
+
+    for (ChildIterator iter = children.begin(); iter != children.end(); iter++) {
+        SPHatchPath *child = *iter;
+        Inkscape::DrawingItem *cai = child->show(drawing, key);
+        if (cai) {
+            ai->appendChild(cai);
+        }
+    }
+
+    View& view = _display.front();
+    _updateView(view);
+
+    return ai;
+}
+
+void SPHatch::hide(unsigned int key) {
+    std::vector<SPHatchPath *> children;
+    _children(children);
+
+    for (ChildIterator iter = children.begin(); iter != children.end(); iter++) {
+        SPHatchPath *child = *iter;
+        child->hide(key);
+    }
+
+    for (ViewIterator iter = _display.begin(); iter != _display.end(); iter++) {
+        if (iter->key == key) {
+            delete iter->arenaitem;
+            _display.erase(iter);
+            return;
+        }
+    }
+
+    g_assert_not_reached();
+}
+
+void SPHatch::_updateView(View &view) {
+    Geom::OptInterval extents = _calculateStripExtents(view.bbox);
+    if (!extents) {
+        return;
+    }
+
+    double tile_x = x();
+    double tile_y = y();
+    double tile_width = pitch();
+    double tile_height = extents->max() - extents->min();
+    double tile_rotate = rotate();
+    double tile_render_y = extents->min();
+
+    if (view.bbox && (hatchUnits() == UNITS_OBJECTBOUNDINGBOX)) {
+        tile_x *= view.bbox->width();
+        tile_y *= view.bbox->height();
+        tile_width *= view.bbox->width();
+        tile_height *= view.bbox->height();
+        tile_render_y *= view.bbox->height();
+    }
+
+    // Pattern size in hatch space
+    Geom::Rect hatch_tile = Geom::Rect::from_xywh(0, tile_render_y, tile_width, tile_height);
+    // Content to bbox
+    Geom::Affine content2ps;
+    if (view.bbox && (hatchContentUnits() == UNITS_OBJECTBOUNDINGBOX)) {
+        content2ps = Geom::Affine(view.bbox->width(), 0.0, 0.0, view.bbox->height(), 0, 0);
+    }
+
+    // Tile (hatch space) to user.
+    Geom::Affine ps2user = Geom::Translate(tile_x, tile_y) * Geom::Rotate::from_degrees(tile_rotate) * hatchTransform();
+
+    view.arenaitem->setChildTransform(content2ps);
+    view.arenaitem->setPatternToUserTransform(ps2user);
+    view.arenaitem->setTileRect(hatch_tile);
+    view.arenaitem->setStyle(this->style);
+}
+
+//calculates strip extents in content space
+Geom::OptInterval SPHatch::_calculateStripExtents(Geom::OptRect bbox) {
+    if (!bbox || (bbox->area() == 0)) {
+        return Geom::OptInterval();
+    }
+
+    double tile_x = x();
+    double tile_y = y();
+    double tile_rotate = rotate();
+
+    Geom::Affine ps2user = Geom::Translate(tile_x, tile_y) * Geom::Rotate::from_degrees(tile_rotate) * hatchTransform();
+    Geom::Affine user2ps = ps2user.inverse();
+
+    Geom::Interval extents;
+    for (int i = 0; i < 4; i++) {
+        Geom::Point corner = bbox->corner(i);
+        Geom::Point corner_ps  =  corner * user2ps;
+        if (i == 0 || corner_ps.y() < extents.min()) {
+            extents.setMin(corner_ps.y());
+        }
+        if (i == 0 || corner_ps.y() > extents.max()) {
+            extents.setMax(corner_ps.y());
+        }
+    }
+
+    if (hatchUnits() == UNITS_OBJECTBOUNDINGBOX) {
+        extents /= bbox->height();
+    }
+
+    return extents;
+}
+
+cairo_pattern_t* SPHatch::pattern_new(cairo_t *base_ct, Geom::OptRect const &bbox, double opacity) {
+    //this code should not be used
+    //it is however required by the fact that SPPaintServer::hatch_new is pure virtual
+    return cairo_pattern_create_rgb(0.5, 0.5, 1.0);
+}
+
+void SPHatch::setBBox(unsigned int key, Geom::OptRect const &bbox) {
+    typedef std::list<View>::iterator ViewIter;
+
+    for (ViewIter iter = _display.begin(); iter != _display.end(); iter++) {
+        if (iter->key == key) {
+            iter->bbox = bbox;
+            break;
+        }
+    }
+}
+
+SPHatch::View::View(Inkscape::DrawingPattern *arenaitem, int key)
+        : arenaitem(arenaitem), key(key)
+{
+}
+/*
+ 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 :