diff options
Diffstat (limited to 'src/object/sp-path.cpp')
| -rw-r--r-- | src/object/sp-path.cpp | 462 |
1 files changed, 462 insertions, 0 deletions
diff --git a/src/object/sp-path.cpp b/src/object/sp-path.cpp new file mode 100644 index 000000000..513e67810 --- /dev/null +++ b/src/object/sp-path.cpp @@ -0,0 +1,462 @@ +/* + * SVG <path> implementation + * + * Authors: + * Lauris Kaplinski <lauris@kaplinski.com> + * David Turner <novalis@gnu.org> + * Abhishek Sharma + * Johan Engelen + * + * Copyright (C) 2004 David Turner + * Copyright (C) 1999-2002 Lauris Kaplinski + * Copyright (C) 2000-2001 Ximian, Inc. + * Copyright (C) 1999-2012 Authors + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <glibmm/i18n.h> + +#include "live_effects/effect.h" +#include "live_effects/lpeobject.h" +#include "live_effects/lpeobject-reference.h" +#include "sp-lpe-item.h" + +#include "display/curve.h" +#include <2geom/curves.h> +#include "helper/geom-curves.h" + +#include "svg/svg.h" +#include "xml/repr.h" +#include "attributes.h" + +#include "sp-path.h" +#include "sp-guide.h" + +#include "document.h" +#include "desktop.h" + +#include "desktop-style.h" +#include "ui/tools/tool-base.h" +#include "inkscape.h" +#include "style.h" +#include "message-stack.h" + +#define noPATH_VERBOSE + +gint SPPath::nodesInPath() const +{ + return _curve ? _curve->nodes_in_path() : 0; +} + +const char* SPPath::displayName() const { + return _("Path"); +} + +gchar* SPPath::description() const { + int count = this->nodesInPath(); + char *lpe_desc = g_strdup(""); + + if (hasPathEffect()) { + Glib::ustring s; + PathEffectList effect_list = this->getEffectList(); + + for (PathEffectList::iterator it = effect_list.begin(); it != effect_list.end(); ++it) + { + LivePathEffectObject *lpeobj = (*it)->lpeobject; + + if (!lpeobj || !lpeobj->get_lpe()) { + break; + } + + if (s.empty()) { + s = lpeobj->get_lpe()->getName(); + } else { + s = s + ", " + lpeobj->get_lpe()->getName(); + } + } + lpe_desc = g_strdup_printf(_(", path effect: %s"), s.c_str()); + } + char *ret = g_strdup_printf(ngettext( + _("%i node%s"), _("%i nodes%s"), count), count, lpe_desc); + g_free(lpe_desc); + return ret; +} + +void SPPath::convert_to_guides() const { + if (!this->_curve) { + return; + } + + std::list<std::pair<Geom::Point, Geom::Point> > pts; + + Geom::Affine const i2dt(this->i2dt_affine()); + Geom::PathVector const & pv = this->_curve->get_pathvector(); + + for(Geom::PathVector::const_iterator pit = pv.begin(); pit != pv.end(); ++pit) { + for(Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_default(); ++cit) { + // only add curves for straight line segments + if( is_straight_curve(*cit) ) + { + pts.push_back(std::make_pair(cit->initialPoint() * i2dt, cit->finalPoint() * i2dt)); + } + } + } + + sp_guide_pt_pairs_to_guides(this->document, pts); +} + +SPPath::SPPath() : SPShape(), connEndPair(this) { +} + +SPPath::~SPPath() { +} + +void SPPath::build(SPDocument *document, Inkscape::XML::Node *repr) { + /* Are these calls actually necessary? */ + this->readAttr( "marker" ); + this->readAttr( "marker-start" ); + this->readAttr( "marker-mid" ); + this->readAttr( "marker-end" ); + + sp_conn_end_pair_build(this); + + SPShape::build(document, repr); + + // this->readAttr( "inkscape:original-d" ); // bug #1299948 + // Why we take the long way of doing this probably needs some explaining: + // + // Normally upon being built, reading the inkscape:original-d attribute + // will cause the path to actually _write to its repr_ in response to this. + // This is bad, bad news if the attached effect refers to a path which + // hasn't been constructed yet. + // + // What will happen is the effect parameter will cause the effect to + // recalculate with a completely different value due to the parameter being + // "empty" -- even worse, an undo event might be created with the bad value, + // and undoing the current action could cause it to revert to the "bad" + // state. (After that, the referred object will be constructed and the + // reference will trigger the path effect to update and commit the right + // value to "d".) + // + // This mild nastiness here (don't recalculate effects on build) prevents a + // plethora of issues with effects with linked parameters doing wild and + // stupid things on new documents upon a mere undo. + + if (gchar const* s = this->getRepr()->attribute("inkscape:original-d")) + { + // Write the value to _curve_before_lpe, do not recalculate effects + Geom::PathVector pv = sp_svg_read_pathv(s); + SPCurve *curve = new SPCurve(pv); + + if (_curve_before_lpe) { + _curve_before_lpe = _curve_before_lpe->unref(); + } + + if (curve) { + _curve_before_lpe = curve->ref(); + } + } + this->readAttr( "d" ); + + /* d is a required attribute */ + char const *d = this->getAttribute("d", NULL); + + if (d == NULL) { + // First see if calculating the path effect will generate "d": + this->update_patheffect(true); + d = this->getAttribute("d", NULL); + + // I guess that didn't work, now we have nothing useful to write ("") + if (d == NULL) { + this->setKeyValue( sp_attribute_lookup("d"), ""); + } + } +} + +void SPPath::release() { + this->connEndPair.release(); + + SPShape::release(); +} + +void SPPath::set(unsigned int key, const gchar* value) { + switch (key) { + case SP_ATTR_INKSCAPE_ORIGINAL_D: + if (value) { + Geom::PathVector pv = sp_svg_read_pathv(value); + SPCurve *curve = new SPCurve(pv); + + if (curve) { + this->set_original_curve(curve, TRUE, true); + curve->unref(); + } + } else { + this->set_original_curve(NULL, TRUE, true); + } + + this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG); + 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) || + this->hasPathEffectOfType(Inkscape::LivePathEffect::BEND_PATH) || + this->hasPathEffectOfType(Inkscape::LivePathEffect::FILL_BETWEEN_MANY) || + this->hasPathEffectOfType(Inkscape::LivePathEffect::FILL_BETWEEN_STROKES) ) + { + // if path has this LPE applied, don't write the transform to the pathdata, but write it 'unoptimized' + // also if the effect is type BEND PATH to fix bug #179842 + this->adjust_livepatheffect(transform); + this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG); + 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 unsuccessful. 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 : |