diff --git a/src/sp-path.cpp b/src/sp-path.cpp
index 7dbe51c265c954703bfadc54ccb9fac64df29d9b..66a70e0f1dc35e78a1f90b9a81f158c57e00a5ba 100644 (file)
--- a/src/sp-path.cpp
+++ b/src/sp-path.cpp
-#define __SP_PATH_C__
-
/*
* SVG <path> implementation
*
* Authors:
* Lauris Kaplinski <lauris@kaplinski.com>
* David Turner <novalis@gnu.org>
+ * Abhishek Sharma
*
* Copyright (C) 2004 David Turner
* Copyright (C) 1999-2002 Lauris Kaplinski
#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 <libnr/n-art-bpath.h>
-#include <libnr/nr-path.h>
#include <libnr/nr-matrix-fns.h>
+#include <2geom/pathvector.h>
+#include <2geom/bezier-curve.h>
+#include <2geom/hvlinesegment.h>
+#include "helper/geom-curves.h"
#include "svg/svg.h"
#include "xml/repr.h"
#include "inkscape.h"
#include "style.h"
#include "message-stack.h"
-#include "prefs-utils.h"
#include "selection.h"
#define noPATH_VERBOSE
static void sp_path_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
static void sp_path_set(SPObject *object, unsigned key, gchar const *value);
-static Inkscape::XML::Node *sp_path_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
-static NR::Matrix sp_path_set_transform(SPItem *item, NR::Matrix const &xform);
+static Inkscape::XML::Node *sp_path_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
+static Geom::Matrix sp_path_set_transform(SPItem *item, Geom::Matrix const &xform);
static gchar * sp_path_description(SPItem *item);
static void sp_path_convert_to_guides(SPItem *item);
static void sp_path_update(SPObject *object, SPCtx *ctx, guint flags);
-static void sp_path_update_patheffect(SPShape *shape, bool write);
+static void sp_path_update_patheffect(SPLPEItem *lpeitem, bool write);
static SPShapeClass *parent_class;
GObjectClass *gobject_class = (GObjectClass *) klass;
SPObjectClass *sp_object_class = (SPObjectClass *) klass;
SPItemClass *item_class = (SPItemClass *) klass;
- SPShapeClass *shape_class = (SPShapeClass *) klass;
+ SPLPEItemClass *lpe_item_class = (SPLPEItemClass *) klass;
parent_class = (SPShapeClass *)g_type_class_peek_parent(klass);
item_class->set_transform = sp_path_set_transform;
item_class->convert_to_guides = sp_path_convert_to_guides;
- shape_class->update_patheffect = sp_path_update_patheffect;
+ lpe_item_class->update_patheffect = sp_path_update_patheffect;
}
sp_nodes_in_path(SPPath *path)
{
SPCurve *curve = SP_SHAPE(path)->curve;
- if (!curve) return 0;
- gint r = curve->end;
- gint i = curve->length - 1;
- if (i > r) i = r; // sometimes after switching from node editor length is wrong, e.g. f6 - draw - f2 - tab - f1, this fixes it
- for (; i >= 0; i --)
- if (SP_CURVE_BPATH(curve)[i].code == NR_MOVETO)
- r --;
- return r;
+ if (!curve)
+ return 0;
+ return curve->nodes_in_path();
}
static gchar *
sp_path_description(SPItem * item)
{
int count = sp_nodes_in_path(SP_PATH(item));
- if (SP_SHAPE(item)->path_effect_href) {
- return g_strdup_printf(ngettext("<b>Path</b> (%i node, path effect)",
- "<b>Path</b> (%i nodes, path effect)",count), count);
+ if (SP_IS_LPE_ITEM(item) && sp_lpe_item_has_path_effect(SP_LPE_ITEM(item))) {
+
+ Glib::ustring s;
+
+ PathEffectList effect_list = sp_lpe_item_get_effect_list(SP_LPE_ITEM(item));
+ 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();
+ }
+
+ return g_strdup_printf(ngettext("<b>Path</b> (%i node, path effect: %s)",
+ "<b>Path</b> (%i nodes, path effect: %s)",count), count, s.c_str());
} else {
return g_strdup_printf(ngettext("<b>Path</b> (%i node)",
"<b>Path</b> (%i nodes)",count), count);
{
SPPath *path = SP_PATH(item);
- SPDocument *doc = SP_OBJECT_DOCUMENT(path);
+ SPCurve *curve = SP_SHAPE(path)->curve;
+ if (!curve) return;
+
std::list<std::pair<Geom::Point, Geom::Point> > pts;
- NR::Matrix const i2d (sp_item_i2d_affine(SP_ITEM(path)));
+ Geom::Matrix const i2d (SP_ITEM(path)->i2d_affine());
- SPCurve *curve = SP_SHAPE(path)->curve;
- if (!curve) return;
- NArtBpath *bpath = SP_CURVE_BPATH(curve);
-
- NR::Point last_pt;
- NR::Point pt;
- for (int i = 0; bpath[i].code != NR_END; i++){
- if (bpath[i].code == NR_LINETO) {
- /* we only convert straight line segments (converting curve segments would be unintuitive) */
- pt = bpath[i].c(3) * i2d;
- pts.push_back(std::make_pair(last_pt.to_2geom(), pt.to_2geom()));
+ Geom::PathVector const & pv = 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() * i2d, cit->finalPoint() * i2d));
+ }
}
-
- /* remember current point for potential reuse in the next step
- (e.g., in case this was an NR_MOVETO or NR_MOVETO_OPEN) */
- last_pt = bpath[i].c(3) * i2d;
}
- sp_guide_pt_pairs_to_guides(doc, pts);
+ sp_guide_pt_pairs_to_guides(inkscape_active_desktop(), pts);
}
/**
sp_path_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
{
/* Are these calls actually necessary? */
- sp_object_read_attr(object, "marker");
- sp_object_read_attr(object, "marker-start");
- sp_object_read_attr(object, "marker-mid");
- sp_object_read_attr(object, "marker-end");
+ object->readAttr( "marker" );
+ object->readAttr( "marker-start" );
+ object->readAttr( "marker-mid" );
+ object->readAttr( "marker-end" );
sp_conn_end_pair_build(object);
@@ -214,13 +224,13 @@ sp_path_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
((SPObjectClass *) parent_class)->build(object, document, repr);
}
- sp_object_read_attr(object, "inkscape:original-d");
- sp_object_read_attr(object, "d");
+ object->readAttr( "inkscape:original-d" );
+ object->readAttr( "d" );
/* d is a required attribute */
- gchar const *d = sp_object_getAttribute(object, "d", NULL);
+ gchar const *d = object->getAttribute("d", NULL);
if (d == NULL) {
- sp_object_set(object, sp_attribute_lookup("d"), "");
+ object->setKeyValue( sp_attribute_lookup("d"), "");
}
}
path->connEndPair.release();
if (path->original_curve) {
- path->original_curve = sp_curve_unref (path->original_curve);
+ path->original_curve = path->original_curve->unref();
}
if (((SPObjectClass *) parent_class)->release) {
switch (key) {
case SP_ATTR_INKSCAPE_ORIGINAL_D:
if (value) {
- NArtBpath *bpath = sp_svg_read_path(value);
- SPCurve *curve = sp_curve_new_from_bpath(bpath);
+ Geom::PathVector pv = sp_svg_read_pathv(value);
+ SPCurve *curve = new SPCurve(pv);
if (curve) {
sp_path_set_original_curve(path, curve, TRUE, true);
- sp_curve_unref(curve);
+ curve->unref();
}
} else {
sp_path_set_original_curve(path, NULL, TRUE, true);
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
break;
case SP_ATTR_D:
- if (!((SPShape *) path)->path_effect_href) {
if (value) {
- NArtBpath *bpath = sp_svg_read_path(value);
- SPCurve *curve = sp_curve_new_from_bpath(bpath);
+ Geom::PathVector pv = sp_svg_read_pathv(value);
+ SPCurve *curve = new SPCurve(pv);
if (curve) {
- sp_shape_set_curve((SPShape *) path, curve, TRUE);
- sp_curve_unref(curve);
+ ((SPShape *) path)->setCurve(curve, TRUE);
+ curve->unref();
}
} else {
- sp_shape_set_curve((SPShape *) path, NULL, TRUE);
+ ((SPShape *) path)->setCurve(NULL, TRUE);
}
object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
- }
break;
case SP_PROP_MARKER:
case SP_PROP_MARKER_START:
object->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:
path->connEndPair.setAttr(key, value);
break;
default:
* Writes the path object into a Inkscape::XML::Node
*/
static Inkscape::XML::Node *
-sp_path_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+sp_path_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
{
SPShape *shape = (SPShape *) object;
if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(object));
repr = xml_doc->createElement("svg:path");
}
+#ifdef PATH_VERBOSE
+g_message("sp_path_write writes 'd' attribute");
+#endif
if ( shape->curve != NULL ) {
- NArtBpath *abp = sp_curve_first_bpath(shape->curve);
- if (abp) {
- gchar *str = sp_svg_write_path(abp);
- repr->setAttribute("d", str);
- g_free(str);
- } else {
- repr->setAttribute("d", "");
- }
+ gchar *str = sp_svg_write_path(shape->curve->get_pathvector());
+ repr->setAttribute("d", str);
+ g_free(str);
} else {
repr->setAttribute("d", NULL);
}
- SPPath *path = (SPPath *) object;
- if ( path->original_curve != NULL ) {
- NArtBpath *abp = sp_curve_first_bpath(path->original_curve);
- if (abp) {
- gchar *str = sp_svg_write_path(abp);
+ if (flags & SP_OBJECT_WRITE_EXT) {
+ SPPath *path = (SPPath *) object;
+ if ( path->original_curve != NULL ) {
+ gchar *str = sp_svg_write_path(path->original_curve->get_pathvector());
repr->setAttribute("inkscape:original-d", str);
g_free(str);
} else {
- repr->setAttribute("inkscape:original-d", "");
+ repr->setAttribute("inkscape:original-d", NULL);
}
- } else {
- repr->setAttribute("inkscape:original-d", NULL);
}
SP_PATH(shape)->connEndPair.writeRepr(repr);
if (((SPObjectClass *)(parent_class))->write) {
- ((SPObjectClass *)(parent_class))->write(object, repr, flags);
+ ((SPObjectClass *)(parent_class))->write(object, xml_doc, repr, flags);
}
return repr;
/**
* Writes the given transform into the repr for the given item.
*/
-static NR::Matrix
-sp_path_set_transform(SPItem *item, NR::Matrix const &xform)
+static Geom::Matrix
+sp_path_set_transform(SPItem *item, Geom::Matrix const &xform)
{
SPShape *shape = (SPShape *) item;
SPPath *path = (SPPath *) item;
if (!shape->curve) { // 0 nodes, nothing to transform
- return NR::identity();
+ return Geom::identity();
}
- // Transform the original-d path or the (ordinary) path
- bool original_path = (bool)path->original_curve;
- SPCurve *srccurve = original_path ? path->original_curve : shape->curve;
- SPCurve *dstcurve = sp_curve_copy(srccurve);
- if (dstcurve) {
- sp_curve_transform(dstcurve, xform);
- if (original_path) {
- sp_path_set_original_curve(path, dstcurve, TRUE, true);
- } else {
- sp_shape_set_curve(shape, dstcurve, TRUE);
- }
- sp_curve_unref(dstcurve);
+ // Transform the original-d path if this is a valid LPE item, other else the (ordinary) path
+ if (path->original_curve && SP_IS_LPE_ITEM(item) &&
+ sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(item))) {
+ path->original_curve->transform(xform);
+ } else {
+ shape->curve->transform(xform);
}
// Adjust stroke
- sp_item_adjust_stroke(item, NR::expansion(xform));
+ item->adjust_stroke(xform.descrim());
// Adjust pattern fill
- sp_item_adjust_pattern(item, xform);
+ item->adjust_pattern(xform);
// Adjust gradient fill
- sp_item_adjust_gradient(item, xform);
+ item->adjust_gradient(xform);
// Adjust LPE
- sp_item_adjust_livepatheffect(item, xform);
+ item->adjust_livepatheffect(xform);
item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
// nothing remains - we've written all of the transform, so return identity
- return NR::identity();
+ return Geom::identity();
}
+
static void
-sp_path_update_patheffect(SPShape *shape, bool write)
+sp_path_update_patheffect(SPLPEItem *lpeitem, bool write)
{
- SPPath *path = (SPPath *) shape;
- if (path->original_curve) {
- SPCurve *curve = sp_curve_copy (path->original_curve);
- sp_shape_perform_path_effect(curve, shape);
- sp_shape_set_curve(shape, curve, TRUE);
- sp_curve_unref(curve);
+ SPShape * const shape = (SPShape *) lpeitem;
+ SPPath * const path = (SPPath *) lpeitem;
+ Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape);
+
+#ifdef PATH_VERBOSE
+g_message("sp_path_update_patheffect");
+#endif
- if (write) {
+ if (path->original_curve && sp_lpe_item_has_path_effect_recursive(lpeitem)) {
+ SPCurve *curve = path->original_curve->copy();
+ /* if a path does not have an lpeitem applied, then reset the curve to the original_curve.
+ * This is very important for LPEs to work properly! (the bbox might be recalculated depending on the curve in shape)*/
+ shape->setCurveInsync(curve, TRUE);
+
+ bool success = sp_lpe_item_perform_path_effect(SP_LPE_ITEM(shape), curve);
+ if (success && write) {
// could also do SP_OBJECT(shape)->updateRepr(); but only the d attribute needs updating.
- Inkscape::XML::Node *repr = SP_OBJECT_REPR(shape);
+#ifdef PATH_VERBOSE
+g_message("sp_path_update_patheffect writes 'd' attribute");
+#endif
if ( shape->curve != NULL ) {
- NArtBpath *abp = sp_curve_first_bpath(shape->curve);
- if (abp) {
- gchar *str = sp_svg_write_path(abp);
- repr->setAttribute("d", str);
- g_free(str);
- } else {
- repr->setAttribute("d", "");
- }
+ gchar *str = sp_svg_write_path(shape->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) {
+ shape->setCurve(oldcurve, TRUE);
+ oldcurve->unref();
+ }
+ }
}
- } else {
-
+ SP_OBJECT(shape)->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 the an effect is present
- * an also triggers a request to update the display. Does not write
-* result to XML when write=false.
+ * 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
sp_path_set_original_curve (SPPath *path, SPCurve *curve, unsigned int owner, bool write)
{
if (path->original_curve) {
- path->original_curve = sp_curve_unref (path->original_curve);
+ path->original_curve = path->original_curve->unref();
}
if (curve) {
if (owner) {
- path->original_curve = sp_curve_ref (curve);
+ path->original_curve = curve->ref();
} else {
- path->original_curve = sp_curve_copy (curve);
+ path->original_curve = curve->copy();
}
}
- sp_path_update_patheffect(path, write);
+ sp_lpe_item_update_patheffect(path, true, write);
SP_OBJECT(path)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
}
sp_path_get_original_curve (SPPath *path)
{
if (path->original_curve) {
- return sp_curve_copy (path->original_curve);
+ return path->original_curve->copy();
}
return NULL;
}
SPCurve*
sp_path_get_curve_for_edit (SPPath *path)
{
- if (path->original_curve) {
+ if (path->original_curve && SP_IS_LPE_ITEM(path) &&
+ sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(path))) {
return sp_path_get_original_curve(path);
} else {
- return sp_shape_get_curve( (SPShape *) path );
+ return ((SPShape *) path)->getCurve();
}
}
const SPCurve*
sp_path_get_curve_reference (SPPath *path)
{
- if (path->original_curve) {
+ if (path->original_curve && SP_IS_LPE_ITEM(path) &&
+ sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(path))) {
return path->original_curve;
} else {
return path->curve;
}
}
-/* Create a single dot represented by a circle */
-void freehand_create_single_dot(SPEventContext *ec, NR::Point const &pt, char const *tool, guint event_state) {
- g_return_if_fail(!strcmp(tool, "tools.freehand.pen") || !strcmp(tool, "tools.freehand.pencil"));
-
- SPDesktop *desktop = SP_EVENT_CONTEXT_DESKTOP(ec);
- Inkscape::XML::Document *xml_doc = sp_document_repr_doc(desktop->doc());
- Inkscape::XML::Node *repr = xml_doc->createElement("svg:path");
- repr->setAttribute("sodipodi:type", "arc");
- SPItem *item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
- Inkscape::GC::release(repr);
-
- /* apply the tool's current style */
- sp_desktop_apply_style_tool(desktop, repr, tool, false);
-
- /* find out stroke width (TODO: is there an easier way??) */
- double stroke_width = 3.0;
- gchar const *style_str = NULL;
- style_str = repr->attribute("style");
- if (style_str) {
- SPStyle *style = sp_style_new(SP_ACTIVE_DOCUMENT);
- sp_style_merge_from_style_string(style, style_str);
- stroke_width = style->stroke_width.computed;
- style->stroke_width.computed = 0;
- sp_style_unref(style);
- }
- /* unset stroke and set fill color to former stroke color */
- gchar * str;
- str = g_strdup_printf("fill:#%06x;stroke:none;", sp_desktop_get_color_tool(desktop, tool, false) >> 8);
- repr->setAttribute("style", str);
- g_free(str);
-
- /* put the circle where the mouse click occurred and set the diameter to the
- current stroke width, multiplied by the amount specified in the preferences */
- NR::Matrix const i2d (sp_item_i2d_affine (item));
- NR::Point pp = pt * i2d;
- double rad = 0.5 * prefs_get_double_attribute(tool, "dot-size", 3.0);
- if (event_state & GDK_MOD1_MASK) {
- /* TODO: We vary the dot size between 0.5*rad and 1.5*rad, where rad is the dot size
- as specified in prefs. Very simple, but it might be sufficient in practice. If not,
- we need to devise something more sophisticated. */
- double s = g_random_double_range(-0.5, 0.5);
- rad *= (1 + s);
- }
- if (event_state & GDK_SHIFT_MASK) {
- // double the point size
- rad *= 2;
- }
-
- sp_repr_set_svg_double (repr, "sodipodi:cx", pp[NR::X]);
- sp_repr_set_svg_double (repr, "sodipodi:cy", pp[NR::Y]);
- sp_repr_set_svg_double (repr, "sodipodi:rx", rad * stroke_width);
- sp_repr_set_svg_double (repr, "sodipodi:ry", rad * stroke_width);
- item->updateRepr();
-
- sp_desktop_selection(desktop)->set(item);
-
- desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Creating single dot"));
- sp_document_done(sp_desktop_document(desktop), SP_VERB_NONE, _("Create single dot"));
-}
-
/*
Local Variables:
mode:c++