inkscape/src/sp-path.cpp

	sp-path.cpp revision 203b91a85466178dd14a24236e0e42539bc4a24b
551N/A/*
943N/A * SVG <path> implementation
551N/A *
551N/A * Authors:
919N/A *   Lauris Kaplinski <lauris@kaplinski.com>
919N/A *   David Turner <novalis@gnu.org>
919N/A *   Abhishek Sharma
919N/A *   Johan Engelen
919N/A *
551N/A * Copyright (C) 2004 David Turner
919N/A * Copyright (C) 1999-2002 Lauris Kaplinski
919N/A * Copyright (C) 2000-2001 Ximian, Inc.
919N/A * Copyright (C) 1999-2012 Authors
551N/A *
919N/A * Released under GNU GPL, read the file 'COPYING' for more information
919N/A */
919N/A
919N/A#ifdef HAVE_CONFIG_H
919N/A# include <config.h>
919N/A#endif
919N/A
551N/A#include <glibmm/i18n.h>
551N/A
551N/A#include "live_effects/effect.h"
551N/A#include "live_effects/lpeobject.h"
551N/A#include "live_effects/lpeobject-reference.h"
551N/A#include "sp-lpe-item.h"
551N/A
551N/A#include "display/curve.h"
551N/A#include <2geom/pathvector.h>
551N/A#include <2geom/bezier-curve.h>
551N/A#include <2geom/hvlinesegment.h>
551N/A#include "helper/geom-curves.h"
551N/A
551N/A#include "svg/svg.h"
551N/A#include "xml/repr.h"
551N/A#include "attributes.h"
551N/A
551N/A#include "sp-path.h"
551N/A#include "sp-guide.h"
551N/A
551N/A#include "document.h"
551N/A#include "desktop.h"
551N/A#include "desktop-handles.h"
551N/A#include "desktop-style.h"
551N/A#include "event-context.h"
551N/A#include "inkscape.h"
551N/A#include "style.h"
551N/A#include "message-stack.h"
551N/A#include "selection.h"
551N/A
551N/A#define noPATH_VERBOSE
551N/A
551N/A#include "sp-factory.h"
551N/A
551N/Anamespace {
551N/A    SPObject* createPath() {
551N/A        return new SPPath();
551N/A    }
551N/A
551N/A    bool pathRegistered = SPFactory::instance().registerObject("svg:path", createPath);
551N/A}
551N/A
551N/Agint SPPath::nodesInPath() const
551N/A{
551N/A    return _curve ? _curve->nodes_in_path() : 0;
551N/A}
551N/A
551N/Aconst char* SPPath::displayName() const {
551N/A    return _("Path");
551N/A}
551N/A
551N/Agchar* SPPath::description() const {
551N/A    int count = this->nodesInPath();
551N/A    char *lpe_desc = g_strdup("");
551N/A
551N/A    if (hasPathEffect()) {
551N/A        Glib::ustring s;
551N/A        PathEffectList effect_list =  this->getEffectList();
551N/A
551N/A        for (PathEffectList::iterator it = effect_list.begin(); it != effect_list.end(); ++it)
551N/A        {
551N/A            LivePathEffectObject *lpeobj = (*it)->lpeobject;
551N/A
551N/A            if (!lpeobj || !lpeobj->get_lpe()) {
551N/A                break;
551N/A            }
551N/A
551N/A            if (s.empty()) {
551N/A                s = lpeobj->get_lpe()->getName();
551N/A            } else {
551N/A                s = s + ", " + lpeobj->get_lpe()->getName();
551N/A            }
551N/A        }
551N/A        lpe_desc = g_strdup_printf(_(", path effect: %s"), s.c_str());
551N/A    }
551N/A    char *ret = g_strdup_printf(ngettext(
551N/A                _("%i node%s"), _("%i nodes%s"), count), count, lpe_desc);
551N/A    g_free(lpe_desc);
551N/A    return ret;
551N/A}
551N/A
551N/Avoid SPPath::convert_to_guides() const {
551N/A    if (!this->_curve) {
551N/A        return;
551N/A    }
551N/A
551N/A    std::list<std::pair<Geom::Point, Geom::Point> > pts;
551N/A
551N/A    Geom::Affine const i2dt(this->i2dt_affine());
551N/A    Geom::PathVector const & pv = this->_curve->get_pathvector();
551N/A
551N/A    for(Geom::PathVector::const_iterator pit = pv.begin(); pit != pv.end(); ++pit) {
551N/A        for(Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_default(); ++cit) {
551N/A            // only add curves for straight line segments
551N/A            if( is_straight_curve(*cit) )
551N/A            {
551N/A                pts.push_back(std::make_pair(cit->initialPoint() * i2dt, cit->finalPoint() * i2dt));
551N/A            }
551N/A        }
551N/A    }
551N/A
551N/A    sp_guide_pt_pairs_to_guides(this->document, pts);
551N/A}
551N/A
551N/ASPPath::SPPath() : SPShape(), connEndPair(this) {
551N/A}
551N/A
551N/ASPPath::~SPPath() {
551N/A}
551N/A
551N/Avoid SPPath::build(SPDocument *document, Inkscape::XML::Node *repr) {
551N/A    /* Are these calls actually necessary? */
551N/A    this->readAttr( "marker" );
551N/A    this->readAttr( "marker-start" );
551N/A    this->readAttr( "marker-mid" );
551N/A    this->readAttr( "marker-end" );
551N/A
551N/A    sp_conn_end_pair_build(this);
551N/A
551N/A    SPShape::build(document, repr);
551N/A
551N/A    this->readAttr( "inkscape:original-d" );
551N/A    this->readAttr( "d" );
551N/A
551N/A    /* d is a required attribute */
551N/A    gchar const *d = this->getAttribute("d", NULL);
551N/A
551N/A    if (d == NULL) {
551N/A        this->setKeyValue( sp_attribute_lookup("d"), "");
551N/A    }
551N/A}
551N/A
551N/Avoid SPPath::release() {
551N/A    this->connEndPair.release();
551N/A
551N/A    SPShape::release();
551N/A}
551N/A
551N/Avoid SPPath::set(unsigned int key, const gchar* value) {
551N/A    switch (key) {
551N/A        case SP_ATTR_INKSCAPE_ORIGINAL_D:
551N/A            if (value) {
551N/A                Geom::PathVector pv = sp_svg_read_pathv(value);
551N/A                SPCurve *curve = new SPCurve(pv);
551N/A
551N/A                if (curve) {
551N/A                    this->set_original_curve(curve, TRUE, true);
551N/A                    curve->unref();
551N/A                }
551N/A            } else {
551N/A                this->set_original_curve(NULL, TRUE, true);
551N/A            }
551N/A
551N/A            this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
551N/A            break;

       case SP_ATTR_D:
            if (value) {
                Geom::PathVector pv = sp_svg_read_pathv(value);
                SPCurve *curve = new SPCurve(pv);

                if (curve) {
                    this->setCurve(curve, TRUE);
                    curve->unref();
                }
            } else {
                this->setCurve(NULL, TRUE);
            }

            this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
            break;

        case SP_PROP_MARKER:
        case SP_PROP_MARKER_START:
        case SP_PROP_MARKER_MID:
        case SP_PROP_MARKER_END:
            sp_shape_set_marker(this, key, value);
            this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
            break;

        case SP_ATTR_CONNECTOR_TYPE:
        case SP_ATTR_CONNECTOR_CURVATURE:
        case SP_ATTR_CONNECTION_START:
        case SP_ATTR_CONNECTION_END:
        case SP_ATTR_CONNECTION_START_POINT:
        case SP_ATTR_CONNECTION_END_POINT:
            this->connEndPair.setAttr(key, value);
            break;

        default:
            SPShape::set(key, value);
            break;
    }
}

Inkscape::XML::Node* SPPath::write(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
    if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
        repr = xml_doc->createElement("svg:path");
    }

#ifdef PATH_VERBOSE
g_message("sp_path_write writes 'd' attribute");
#endif

    if ( this->_curve != NULL ) {
        gchar *str = sp_svg_write_path(this->_curve->get_pathvector());
        repr->setAttribute("d", str);
        g_free(str);
    } else {
        repr->setAttribute("d", NULL);
    }

    if (flags & SP_OBJECT_WRITE_EXT) {
        if ( this->_curve_before_lpe != NULL ) {
            gchar *str = sp_svg_write_path(this->_curve_before_lpe->get_pathvector());
            repr->setAttribute("inkscape:original-d", str);
            g_free(str);
        } else {
            repr->setAttribute("inkscape:original-d", NULL);
        }
    }

    this->connEndPair.writeRepr(repr);

    SPShape::write(xml_doc, repr, flags);

    return repr;
}

void SPPath::update(SPCtx *ctx, guint flags) {
    if (flags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG | SP_OBJECT_VIEWPORT_MODIFIED_FLAG)) {
        flags &= ~SP_OBJECT_USER_MODIFIED_FLAG_B; // since we change the description, it's not a "just translation" anymore
    }

    SPShape::update(ctx, flags);

    this->connEndPair.update();
}

Geom::Affine SPPath::set_transform(Geom::Affine const &transform) {
    if (!_curve) { // 0 nodes, nothing to transform
        return Geom::identity();
    }

    // Transform the original-d path if this is a valid LPE this, other else the (ordinary) path
    if (_curve_before_lpe && hasPathEffectRecursive()) {
        if (this->hasPathEffectOfType(Inkscape::LivePathEffect::CLONE_ORIGINAL)) {
            // if path has the CLONE_ORIGINAL LPE applied, don't write the transform to the pathdata, but write it 'unoptimized'
            return transform;
        } else {
            _curve_before_lpe->transform(transform);
        }
    } else {
        _curve->transform(transform);
    }

    // Adjust stroke
    this->adjust_stroke(transform.descrim());

    // Adjust pattern fill
    this->adjust_pattern(transform);

    // Adjust gradient fill
    this->adjust_gradient(transform);

    // Adjust LPE
    this->adjust_livepatheffect(transform);

    this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);

    // nothing remains - we've written all of the transform, so return identity
    return Geom::identity();
}


void SPPath::update_patheffect(bool write) {
    Inkscape::XML::Node *repr = this->getRepr();

#ifdef PATH_VERBOSE
g_message("sp_path_update_patheffect");
#endif

    if (_curve_before_lpe && hasPathEffectRecursive()) {
        SPCurve *curve = _curve_before_lpe->copy();
        /* if a path has an lpeitem applied, then reset the curve to the _curve_before_lpe.
         * This is very important for LPEs to work properly! (the bbox might be recalculated depending on the curve in shape)*/
        this->setCurveInsync(curve, TRUE);

        bool success = this->performPathEffect(curve);

        if (success && write) {
            // could also do this->getRepr()->updateRepr();  but only the d attribute needs updating.
#ifdef PATH_VERBOSE
g_message("sp_path_update_patheffect writes 'd' attribute");
#endif

            if (_curve) {
                gchar *str = sp_svg_write_path(this->_curve->get_pathvector());
                repr->setAttribute("d", str);
                g_free(str);
            } else {
                repr->setAttribute("d", NULL);
            }
        } else if (!success) {
            // LPE was unsuccesfull. Read the old 'd'-attribute.
            if (gchar const * value = repr->attribute("d")) {
                Geom::PathVector pv = sp_svg_read_pathv(value);
                SPCurve *oldcurve = new SPCurve(pv);

                if (oldcurve) {
                    this->setCurve(oldcurve, TRUE);
                    oldcurve->unref();
                }
            }
        }

        this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
        curve->unref();
    }
}


/**
 * Adds a original_curve to the path.  If owner is specified, a reference
 * will be made, otherwise the curve will be copied into the path.
 * Any existing curve in the path will be unreferenced first.
 * This routine triggers reapplication of an effect if present
 * and also triggers a request to update the display. Does not write
 * result to XML when write=false.
 */
void SPPath::set_original_curve (SPCurve *new_curve, unsigned int owner, bool write)
{
    if (_curve_before_lpe) {
        _curve_before_lpe = _curve_before_lpe->unref();
    }

    if (new_curve) {
        if (owner) {
            _curve_before_lpe = new_curve->ref();
        } else {
            _curve_before_lpe = new_curve->copy();
        }
    }

    sp_lpe_item_update_patheffect(this, true, write);
    requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}

/**
 * Return duplicate of _curve_before_lpe (if any exists) or NULL if there is no curve
 */
SPCurve * SPPath::get_original_curve () const
{
    if (_curve_before_lpe) {
        return _curve_before_lpe->copy();
    }

    return NULL;
}

/**
 * Return duplicate of edittable curve which is _curve_before_lpe if it exists or
 * shape->curve if not.
 */
SPCurve* SPPath::get_curve_for_edit () const
{
    if (_curve_before_lpe && hasPathEffectRecursive()) {
        return get_original_curve();
    } else {
        return getCurve();
    }
}

/**
 * Returns \c _curve_before_lpe if it is not NULL and a valid LPE is applied or
 * \c curve if not.
 */
const SPCurve* SPPath::get_curve_reference () const
{
    if (_curve_before_lpe && hasPathEffectRecursive()) {
        return _curve_before_lpe;
    } else {
        return _curve;
    }
}

/**
 * Returns \c _curve_before_lpe if it is not NULL and a valid LPE is applied or \c curve if not.
 * \todo should only be available to class friends!
 */
SPCurve* SPPath::get_curve ()
{
    if (_curve_before_lpe && hasPathEffectRecursive()) {
        return _curve_before_lpe;
    } else {
        return _curve;
    }
}

/*
  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 :