diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index ffc99f5789af92ed2552adcd4ef6023a9d61b967..3f9754bbb0f74d5167945949bca66cc7ec333bf3 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
#include <glibmm/i18n.h>
#include "libnr/n-art-bpath.h"
#include "libnr/nr-path.h"
+#include <2geom/pathvector.h>
+#include <2geom/sbasis-to-bezier.h>
#include "helper/units.h"
#include "knot.h"
#include "inkscape.h"
#include <cstring>
#include <string>
#include "live_effects/lpeobject.h"
+#include "live_effects/effect.h"
#include "live_effects/parameter/parameter.h"
#include "util/mathfns.h"
#include "display/snap-indicator.h"
/* Creation from object */
-static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b, gchar const *t);
-static gchar *parse_nodetypes(gchar const *types, gint length);
+static NArtBpath const * subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath const *b, Inkscape::NodePath::NodeType const *t);
+static void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t);
+static void add_curve_to_subpath( Inkscape::NodePath::Path *np, Inkscape::NodePath::SubPath *sp, Geom::Curve const & c,
+ Inkscape::NodePath::NodeType const *t, guint & i, NR::Point & ppos, NRPathcode & pcode );
+static Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, gint length);
/* Object updating */
@@ -151,6 +157,20 @@ static void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve)
// active_node indicates mouseover node
Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL;
+static void sp_nodepath_draw_helper_curve(Inkscape::NodePath::Path *np, SPDesktop *desktop) {
+ // Draw helper curve
+ if (np->show_helperpath) {
+ SPCurve *helper_curve = np->curve->copy();
+ helper_curve->transform(np->i2d );
+ np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(desktop), helper_curve);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
+ sp_canvas_item_move_to_z(np->helper_path, 0);
+ sp_canvas_item_show(np->helper_path);
+ helper_curve->unref();
+ }
+}
+
/**
* \brief Creates new nodepath from item
*/
@@ -180,17 +200,16 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
if (curve == NULL)
return NULL;
- NArtBpath *bpath = sp_curve_first_bpath(curve);
- gint length = curve->end;
+ gint length = curve->get_length();
if (length == 0) {
- sp_curve_unref(curve);
+ curve->unref();
return NULL; // prevent crash for one-node paths
}
//Create new nodepath
Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1);
if (!np) {
- sp_curve_unref(curve);
+ curve->unref();
return NULL;
}
@@ -206,8 +225,14 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
np->helper_path = NULL;
np->helperpath_rgba = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff);
np->helperpath_width = 1.0;
- np->curve = sp_curve_copy(curve);
- np->show_helperpath = prefs_get_int_attribute ("tools.nodes", "show_helperpath", 0) == 1;
+ np->curve = curve->copy();
+ np->show_helperpath = (prefs_get_int_attribute ("tools.nodes", "show_helperpath", 0) == 1);
+ if (SP_IS_LPE_ITEM(object)) {
+ Inkscape::LivePathEffect::Effect *lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(object));
+ if (lpe && lpe->isVisible() && lpe->showOrigPath()) {
+ np->show_helperpath = true;
+ }
+ }
np->straight_path = false;
if (IS_LIVEPATHEFFECT(object) && item) {
np->item = item;
// to a change in repr by regenerating nodepath --bb
sp_object_read_attr(SP_OBJECT(np->item), "transform");
- np->i2d = sp_item_i2d_affine(np->item);
+ np->i2d = from_2geom(sp_item_i2d_affine(np->item));
np->d2i = np->i2d.inverse();
np->repr = repr;
if ( sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object)) ) {
np->repr_key = g_strdup("inkscape:original-d");
- LivePathEffectObject *lpeobj = sp_lpe_item_get_livepatheffectobject(SP_LPE_ITEM(np->object));
- if (lpeobj && lpeobj->lpe) {
- lpeobj->lpe->setup_nodepath(np);
+ Inkscape::LivePathEffect::Effect* lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(np->object));
+ if (lpe) {
+ lpe->setup_nodepath(np);
}
} else {
np->repr_key = g_strdup("d");
@@ -246,34 +271,26 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
}
gchar const *nodetypes = np->repr->attribute(np->repr_nodetypes_key);
- gchar *typestr = parse_nodetypes(nodetypes, length);
+ Inkscape::NodePath::NodeType *typestr = parse_nodetypes(nodetypes, length);
// create the subpath(s) from the bpath
- NArtBpath *b = bpath;
- while (b->code != NR_END) {
- b = subpath_from_bpath(np, b, typestr + (b - bpath));
- }
+// NArtBpath const *bpath = curve->get_bpath();
+// NArtBpath const *b = bpath;
+// while (b->code != NR_END) {
+// b = subpath_from_bpath(np, b, typestr + (b - bpath));
+// }
+ subpaths_from_pathvector(np, curve->get_pathvector(), typestr);
// reverse the list, because sp_nodepath_subpath_new() used g_list_prepend instead of append (for speed)
np->subpaths = g_list_reverse(np->subpaths);
- g_free(typestr);
- sp_curve_unref(curve);
+ delete[] typestr;
+ curve->unref();
// create the livarot representation from the same item
sp_nodepath_ensure_livarot_path(np);
- // Draw helper curve
- if (np->show_helperpath) {
- SPCurve *helper_curve = sp_curve_copy(np->curve);
- sp_curve_transform(helper_curve, np->i2d );
- np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(desktop), helper_curve);
- sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
- sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
- sp_canvas_item_move_to_z(np->helper_path, 0);
- sp_canvas_item_show(np->helper_path);
- sp_curve_unref(helper_curve);
- }
+ sp_nodepath_draw_helper_curve(np, desktop);
return np;
}
gtk_object_destroy(temp);
}
if (np->curve) {
- sp_curve_unref(np->curve);
+ np->curve->unref();
np->curve = NULL;
}
{
if (np && np->livarot_path == NULL) {
SPCurve *curve = create_curve(np);
- NArtBpath *bpath = SP_CURVE_BPATH(curve);
- np->livarot_path = bpath_to_Path(bpath);
+ np->livarot_path = new Path;
+ np->livarot_path->LoadPathVector(curve->get_pathvector());
if (np->livarot_path)
np->livarot_path->ConvertWithBackData(0.01);
- sp_curve_unref(curve);
+ curve->unref();
}
}
/**
* Create new nodepath from b, make it subpath of np.
* \param t The node type.
- * \todo Fixme: t should be a proper type, rather than gchar
*/
-static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b, gchar const *t)
+static NArtBpath const * subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath const *b, Inkscape::NodePath::NodeType const *t)
{
NR::Point ppos, pos, npos;
@@ -459,7 +475,7 @@ static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b,
npos = pos;
}
Inkscape::NodePath::Node *n;
- n = sp_nodepath_node_new(sp, NULL, (Inkscape::NodePath::NodeType) *t, NR_MOVETO, &pos, &pos, &npos);
+ n = sp_nodepath_node_new(sp, NULL, *t, NR_MOVETO, &pos, &pos, &npos);
g_assert(sp->first == n);
g_assert(sp->last == n);
@@ -488,13 +504,80 @@ static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b,
}
/**
- * Convert from sodipodi:nodetypes to new style type string.
+ * Create new nodepaths from pathvector, make it subpaths of np.
+ * \param t The node type array.
+ */
+static void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t)
+{
+ guint i = 0; // index into node type array
+ for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit) {
+ if (pit->empty())
+ continue; // don't add single knot paths
+
+ Inkscape::NodePath::SubPath *sp = sp_nodepath_subpath_new(np);
+
+ NR::Point ppos = from_2geom(pit->initialPoint()) * np->i2d;
+ NRPathcode pcode = NR_MOVETO;
+
+ for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit) {
+ add_curve_to_subpath(np, sp, *cit, t, i, ppos, pcode);
+ }
+
+ if (pit->closed()) {
+ // Add last knot (because sp_nodepath_subpath_close kills the last knot)
+ /* Remember that last closing segment is always a lineto, but its length can be zero if the path is visually closed already
+ * If the length is zero, don't add it to the nodepath. */
+ Geom::Curve const &closing_seg = pit->back_closed();
+ if ( ! closing_seg.isDegenerate() ) {
+ NR::Point pos = from_2geom(closing_seg.finalPoint()) * np->i2d;
+ sp_nodepath_node_new(sp, NULL, t[i++], NR_LINETO, &pos, &pos, &pos);
+ }
+
+ sp_nodepath_subpath_close(sp);
+ }
+ }
+}
+// should add initial point of curve with type of previous curve:
+static void add_curve_to_subpath(Inkscape::NodePath::Path *np, Inkscape::NodePath::SubPath *sp, Geom::Curve const & c, Inkscape::NodePath::NodeType const *t, guint & i,
+ NR::Point & ppos, NRPathcode & pcode)
+{
+ if( dynamic_cast<Geom::LineSegment const*>(&c) ||
+ dynamic_cast<Geom::HLineSegment const*>(&c) ||
+ dynamic_cast<Geom::VLineSegment const*>(&c) )
+ {
+ NR::Point pos = from_2geom(c.initialPoint()) * np->i2d;
+ sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &pos);
+ ppos = from_2geom(c.finalPoint());
+ pcode = NR_LINETO;
+ }
+ else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast<Geom::CubicBezier const*>(&c)) {
+ std::vector<Geom::Point> points = cubic_bezier->points();
+ NR::Point pos = from_2geom(points[0]) * np->i2d;
+ NR::Point npos = from_2geom(points[1]) * np->i2d;
+ sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &npos);
+ ppos = from_2geom(points[2]) * np->i2d;
+ pcode = NR_CURVETO;
+ }
+ else {
+ //this case handles sbasis as well as all other curve types
+ Geom::Path sbasis_path = Geom::cubicbezierpath_from_sbasis(c.toSBasis(), 0.1);
+
+ for(Geom::Path::iterator iter = sbasis_path.begin(); iter != sbasis_path.end(); ++iter) {
+ add_curve_to_subpath(np, sp, *iter, t, i, ppos, pcode);
+ }
+ }
+}
+
+
+/**
+ * Convert from sodipodi:nodetypes to new style type array.
*/
-static gchar *parse_nodetypes(gchar const *types, gint length)
+static
+Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, gint length)
{
g_assert(length > 0);
- gchar *typestr = g_new(gchar, length + 1);
+ Inkscape::NodePath::NodeType *typestr = new Inkscape::NodePath::NodeType[length + 1];
gint pos = 0;
{
g_assert(np);
- sp_curve_unref(np->curve);
+ np->curve->unref();
np->curve = create_curve(np);
sp_nodepath_set_curve(np, np->curve);
if (np->show_helperpath) {
- SPCurve * helper_curve = sp_curve_copy(np->curve);
- sp_curve_transform(helper_curve, np->i2d );
+ SPCurve * helper_curve = np->curve->copy();
+ helper_curve->transform(np->i2d );
sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
- sp_curve_unref(helper_curve);
+ helper_curve->unref();
}
+
+ // now that nodepath and knotholder can be enabled simultaneously, we must update the knotholder, too
+ // TODO: this should be done from ShapeEditor!! nodepath should be oblivious of knotholder!
+ np->shape_editor->update_knotholder();
}
/**
Inkscape::XML::Node *repr = np->object->repr;
- sp_curve_unref(np->curve);
+ np->curve->unref();
np->curve = create_curve(np);
gchar *typestr = create_typestr(np);
- gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
+ gchar *svgpath = sp_svg_write_path(np->curve->get_pathvector());
// determine if path has an effect applied and write to correct "d" attribute.
if (repr->attribute(np->repr_key) == NULL || strcmp(svgpath, repr->attribute(np->repr_key))) { // d changed
g_free(typestr);
if (np->show_helperpath) {
- SPCurve * helper_curve = sp_curve_copy(np->curve);
- sp_curve_transform(helper_curve, np->i2d );
+ SPCurve * helper_curve = np->curve->copy();
+ helper_curve->transform(np->i2d );
sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
- sp_curve_unref(helper_curve);
+ helper_curve->unref();
}
}
SPCurve *curve = create_curve(np);
gchar *typestr = create_typestr(np);
- gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
+ gchar *svgpath = sp_svg_write_path(curve->get_pathvector());
new_repr->setAttribute(np->repr_key, svgpath);
new_repr->setAttribute(np->repr_nodetypes_key, typestr);
Inkscape::GC::release(new_repr);
g_free(svgpath);
g_free(typestr);
- sp_curve_unref(curve);
+ curve->unref();
}
/**
*/
static SPCurve *create_curve(Inkscape::NodePath::Path *np)
{
- SPCurve *curve = sp_curve_new();
+ SPCurve *curve = new SPCurve();
for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) {
Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *) spl->data;
- sp_curve_moveto(curve,
- sp->first->pos * np->d2i);
+ curve->moveto(sp->first->pos * np->d2i);
Inkscape::NodePath::Node *n = sp->first->n.other;
while (n) {
NR::Point const end_pt = n->pos * np->d2i;
switch (n->code) {
case NR_LINETO:
- sp_curve_lineto(curve, end_pt);
+ curve->lineto(end_pt);
break;
case NR_CURVETO:
- sp_curve_curveto(curve,
- n->p.other->n.pos * np->d2i,
+ curve->curveto(n->p.other->n.pos * np->d2i,
n->p.pos * np->d2i,
end_pt);
break;
}
}
if (sp->closed) {
- sp_curve_closepath(curve);
+ curve->closepath();
}
}
@@ -876,17 +961,23 @@ static Inkscape::NodePath::Node *sp_nodepath_node_break(Inkscape::NodePath::Node
Inkscape::NodePath::SubPath *newsubpath = sp_nodepath_subpath_new(np);
// duplicate the break node as start of the new subpath
- Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(newsubpath, NULL, (Inkscape::NodePath::NodeType)node->type, NR_MOVETO, &node->pos, &node->pos, &node->n.pos);
-
- while (node->n.other) { // copy the remaining nodes into the new subpath
- Inkscape::NodePath::Node *n = node->n.other;
- Inkscape::NodePath::Node *nn = sp_nodepath_node_new(newsubpath, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos);
- if (n->selected) {
- sp_nodepath_node_select(nn, TRUE, TRUE); //preserve selection
- }
- sp_nodepath_node_destroy(n); // remove the point on the original subpath
+ Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(newsubpath, NULL, (Inkscape::NodePath::NodeType)node->type, NR_MOVETO, &node->pos, &node->pos, &node->n.pos);
+
+ // attach rest of curve to new node
+ g_assert(node->n.other);
+ newnode->n.other = node->n.other; node->n.other = NULL;
+ newnode->n.other->p.other = newnode;
+ newsubpath->last = sp->last;
+ sp->last = node;
+ node = newnode;
+ while (node->n.other) {
+ node = node->n.other;
+ node->subpath = newsubpath;
+ sp->nodes = g_list_remove(sp->nodes, node);
+ newsubpath->nodes = g_list_prepend(newsubpath->nodes, node);
}
+
return newnode;
}
}
@@ -970,9 +1061,6 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
g_assert(node);
g_assert(node->subpath);
- if (type == static_cast<Inkscape::NodePath::NodeType>(static_cast< guint >(node->type) ) )
- return node;
-
if ((node->p.other != NULL) && (node->n.other != NULL)) {
if ((node->code == NR_LINETO) && (node->n.other->code == NR_LINETO)) {
type =Inkscape::NodePath::NODE_CUSP;
@@ -1007,48 +1095,157 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
return node;
}
+bool
+sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side)
+{
+ Inkscape::NodePath::Node *othernode = side->other;
+ if (!othernode)
+ return false;
+ NRPathcode const code = sp_node_path_code_from_side(node, side);
+ if (code == NR_LINETO)
+ return true;
+ Inkscape::NodePath::NodeSide *other_to_me = NULL;
+ if (&node->p == side) {
+ other_to_me = &othernode->n;
+ } else if (&node->n == side) {
+ other_to_me = &othernode->p;
+ }
+ if (!other_to_me)
+ return false;
+ bool is_line =
+ (NR::L2(othernode->pos - other_to_me->pos) < 1e-6 &&
+ NR::L2(node->pos - side->pos) < 1e-6);
+ return is_line;
+}
+
/**
- * Same as sp_nodepath_set_node_type(), but also converts, if necessary,
- * adjacent segments from lines to curves.
+ * Same as sp_nodepath_set_node_type(), but also converts, if necessary, adjacent segments from
+ * lines to curves. If adjacent to one line segment, pulls out or rotates opposite handle to align
+ * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too.
+ * If already cusp and set to cusp, retracts handles.
*/
void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
{
- bool p_line = (node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos);
- bool n_line = (node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos);
-
if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
- if (p_line && n_line) {
- // only if both adjacent segments are lines,
- // convert both to curves:
- node->code = NR_CURVETO;
- node->n.other->code = NR_CURVETO;
+/*
+ Here's the algorithm of converting node to smooth (Shift+S or toolbar button), in pseudocode:
+
+ if (two_handles) {
+ // do nothing, adjust_handles called via set_node_type will line them up
+ } else if (one_handle) {
+ if (opposite_to_handle_is_line) {
+ if (lined_up) {
+ // already half-smooth; pull opposite handle too making it fully smooth
+ } else {
+ // do nothing, adjust_handles will line the handle up, producing a half-smooth node
+ }
+ } else {
+ // pull opposite handle in line with the existing one
+ }
+ } else if (no_handles) {
+ if (both_segments_are_lines OR both_segments_are_curves) {
+ //pull both handles
+ } else {
+ // pull the handle opposite to line segment, making node half-smooth
+ }
+ }
+*/
+ bool p_has_handle = (NR::L2(node->pos - node->p.pos) > 1e-6);
+ bool n_has_handle = (NR::L2(node->pos - node->n.pos) > 1e-6);
+ bool p_is_line = sp_node_side_is_line(node, &node->p);
+ bool n_is_line = sp_node_side_is_line(node, &node->n);
+
+ if (p_has_handle && n_has_handle) {
+ // do nothing, adjust_handles will line them up
+ } else if (p_has_handle || n_has_handle) {
+ if (p_has_handle && n_is_line) {
+ Radial line (node->n.other->pos - node->pos);
+ Radial handle (node->pos - node->p.pos);
+ if (fabs(line.a - handle.a) < 1e-3) { // lined up
+ // already half-smooth; pull opposite handle too making it fully smooth
+ node->n.pos = node->pos + (node->n.other->pos - node->pos) / 3;
+ } else {
+ // do nothing, adjust_handles will line the handle up, producing a half-smooth node
+ }
+ } else if (n_has_handle && p_is_line) {
+ Radial line (node->p.other->pos - node->pos);
+ Radial handle (node->pos - node->n.pos);
+ if (fabs(line.a - handle.a) < 1e-3) { // lined up
+ // already half-smooth; pull opposite handle too making it fully smooth
+ node->p.pos = node->pos + (node->p.other->pos - node->pos) / 3;
+ } else {
+ // do nothing, adjust_handles will line the handle up, producing a half-smooth node
+ }
+ } else if (p_has_handle && node->n.other) {
+ // pull n handle
+ node->n.other->code = NR_CURVETO;
+ double len = (type == Inkscape::NodePath::NODE_SYMM)?
+ NR::L2(node->p.pos - node->pos) :
+ NR::L2(node->n.other->pos - node->pos) / 3;
+ node->n.pos = node->pos - (len / NR::L2(node->p.pos - node->pos)) * (node->p.pos - node->pos);
+ } else if (n_has_handle && node->p.other) {
+ // pull p handle
+ node->code = NR_CURVETO;
+ double len = (type == Inkscape::NodePath::NODE_SYMM)?
+ NR::L2(node->n.pos - node->pos) :
+ NR::L2(node->p.other->pos - node->pos) / 3;
+ node->p.pos = node->pos - (len / NR::L2(node->n.pos - node->pos)) * (node->n.pos - node->pos);
+ }
+ } else if (!p_has_handle && !n_has_handle) {
+ if ((p_is_line && n_is_line) || (!p_is_line && node->p.other && !n_is_line && node->n.other)) {
+ // no handles, but both segments are either lnes or curves:
+ //pull both handles
+
+ // convert both to curves:
+ node->code = NR_CURVETO;
+ node->n.other->code = NR_CURVETO;
- NR::Point leg_prev = node->pos - node->p.other->pos;
- NR::Point leg_next = node->pos - node->n.other->pos;
+ NR::Point leg_prev = node->pos - node->p.other->pos;
+ NR::Point leg_next = node->pos - node->n.other->pos;
- double norm_leg_prev = L2(leg_prev);
- double norm_leg_next = L2(leg_next);
+ double norm_leg_prev = L2(leg_prev);
+ double norm_leg_next = L2(leg_next);
- // delta has length 1 and is orthogonal to bisecting line
- NR::Point delta;
- if (norm_leg_next > 0.0) {
- delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
- (&delta)->normalize();
- }
+ NR::Point delta;
+ if (norm_leg_next > 0.0) {
+ delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
+ (&delta)->normalize();
+ }
+
+ if (type == Inkscape::NodePath::NODE_SYMM) {
+ double norm_leg_avg = (norm_leg_prev + norm_leg_next) / 2;
+ node->p.pos = node->pos + 0.3 * norm_leg_avg * delta;
+ node->n.pos = node->pos - 0.3 * norm_leg_avg * delta;
+ } else {
+ // length of handle is proportional to distance to adjacent node
+ node->p.pos = node->pos + 0.3 * norm_leg_prev * delta;
+ node->n.pos = node->pos - 0.3 * norm_leg_next * delta;
+ }
- if (type == Inkscape::NodePath::NODE_SYMM) {
- double norm_leg_avg = (norm_leg_prev + norm_leg_next) / 2;
- node->p.pos = node->pos + 0.3 * norm_leg_avg * delta;
- node->n.pos = node->pos - 0.3 * norm_leg_avg * delta;
} else {
- // length of handle is proportional to distance to adjacent node
- node->p.pos = node->pos + 0.3 * norm_leg_prev * delta;
- node->n.pos = node->pos - 0.3 * norm_leg_next * delta;
+ // pull the handle opposite to line segment, making it half-smooth
+ if (p_is_line && node->n.other) {
+ if (type != Inkscape::NodePath::NODE_SYMM) {
+ // pull n handle
+ node->n.other->code = NR_CURVETO;
+ double len = NR::L2(node->n.other->pos - node->pos) / 3;
+ node->n.pos = node->pos + (len / NR::L2(node->p.other->pos - node->pos)) * (node->p.other->pos - node->pos);
+ }
+ } else if (n_is_line && node->p.other) {
+ if (type != Inkscape::NodePath::NODE_SYMM) {
+ // pull p handle
+ node->code = NR_CURVETO;
+ double len = NR::L2(node->p.other->pos - node->pos) / 3;
+ node->p.pos = node->pos + (len / NR::L2(node->n.other->pos - node->pos)) * (node->n.other->pos - node->pos);
+ }
+ }
}
-
- sp_node_update_handles(node);
}
+ } else if (type == Inkscape::NodePath::NODE_CUSP && node->type == Inkscape::NodePath::NODE_CUSP) {
+ // cusping a cusp: retract nodes
+ node->p.pos = node->pos;
+ node->n.pos = node->pos;
}
sp_nodepath_set_node_type (node, type);
* Call sp_node_moveto() for node selection and handle possible snapping.
*/
static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, NR::Coord dx, NR::Coord dy,
- bool const snap = true)
+ bool const snap, bool constrained = false,
+ Inkscape::Snapper::ConstraintLine const &constraint = NR::Point())
{
NR::Coord best = NR_HUGE;
NR::Point delta(dx, dy);
NR::Point best_pt = delta;
Inkscape::SnappedPoint best_abs;
-
if (snap) {
/* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and
@@ -1127,8 +1324,16 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- Inkscape::SnappedPoint s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
- if (s.getDistance() < best) {
+ m.setup(NULL, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
+ Inkscape::SnappedPoint s;
+ if (constrained) {
+ Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
+ dedicated_constraint.setPoint(n->pos);
+ s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, dedicated_constraint);
+ } else {
+ s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta);
+ }
+ if (s.getSnapped() && (s.getDistance() < best)) {
best = s.getDistance();
best_abs = s;
best_pt = s.getPoint() - n->pos;
@@ -1137,6 +1342,8 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
if (best_abs.getSnapped()) {
nodepath->desktop->snapindicator->set_new_snappoint(best_abs);
+ } else {
+ nodepath->desktop->snapindicator->remove_snappoint();
}
}
{
if (!nodepath) return;
+ GList *tempin = g_list_copy(nodepath->selected);
GList *temp = NULL;
- for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+ for (GList *l = tempin; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
Inkscape::NodePath::Node *nn = sp_nodepath_node_break(n);
if (nn == NULL) continue; // no break, no new node
temp = g_list_prepend(temp, nn);
}
+ g_list_free(tempin);
if (temp) {
sp_nodepath_deselect(nodepath);
//if these nodes are smooth or symmetrical, the endpoints will be thrown out of sync.
//make sure these nodes are changed to cusp nodes so that, once the endpoints are moved,
//the resulting nodes behave as expected.
- sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP);
- sp_nodepath_convert_node_type(sample_end, Inkscape::NodePath::NODE_CUSP);
+ if (sample_cursor->type != Inkscape::NodePath::NODE_CUSP)
+ sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP);
+ if (sample_end->type != Inkscape::NodePath::NODE_CUSP)
+ sp_nodepath_convert_node_type(sample_end, Inkscape::NodePath::NODE_CUSP);
//adjust endpoints
sample_cursor->n.pos = bez[1];
@@ -2965,53 +3176,41 @@ void restore_nodepath_selection(Inkscape::NodePath::Path *nodepath, GList *r)
}
}
}
-
}
+
/**
\brief Adjusts handle according to node type and line code.
*/
static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust)
{
- double len, otherlen, linelen;
-
g_assert(node);
Inkscape::NodePath::NodeSide *me = sp_node_get_side(node, which_adjust);
Inkscape::NodePath::NodeSide *other = sp_node_opposite_side(node, me);
- /** \todo fixme: */
+ // nothing to do if we are an end node
if (me->other == NULL) return;
if (other->other == NULL) return;
- /* I have line */
+ // nothing to do if we are a cusp node
+ if (node->type == Inkscape::NodePath::NODE_CUSP) return;
- NRPathcode mecode, ocode;
+ // nothing to do if it's a line from the specified side of the node (i.e. no handle to adjust)
+ NRPathcode mecode;
if (which_adjust == 1) {
mecode = (NRPathcode)me->other->code;
- ocode = (NRPathcode)node->code;
} else {
mecode = (NRPathcode)node->code;
- ocode = (NRPathcode)other->other->code;
}
-
if (mecode == NR_LINETO) return;
- /* I am curve */
-
- if (other->other == NULL) return;
-
- /* Other has line */
-
- if (node->type == Inkscape::NodePath::NODE_CUSP) return;
-
- NR::Point delta;
- if (ocode == NR_LINETO) {
- /* other is lineto, we are either smooth or symm */
+ if (sp_node_side_is_line(node, other)) {
+ // other is a line, and we are either smooth or symm
Inkscape::NodePath::Node *othernode = other->other;
- len = NR::L2(me->pos - node->pos);
- delta = node->pos - othernode->pos;
- linelen = NR::L2(delta);
+ double len = NR::L2(me->pos - node->pos);
+ NR::Point delta = node->pos - othernode->pos;
+ double linelen = NR::L2(delta);
if (linelen < 1e-18)
return;
me->pos = node->pos + (len / linelen)*delta;
@@ -3019,19 +3218,17 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
}
if (node->type == Inkscape::NodePath::NODE_SYMM) {
-
+ // symmetrize
me->pos = 2 * node->pos - other->pos;
return;
+ } else {
+ // smoothify
+ double len = NR::L2(me->pos - node->pos);
+ NR::Point delta = other->pos - node->pos;
+ double otherlen = NR::L2(delta);
+ if (otherlen < 1e-18) return;
+ me->pos = node->pos - (len / otherlen) * delta;
}
-
- /* We are smooth */
-
- len = NR::L2(me->pos - node->pos);
- delta = other->pos - node->pos;
- otherlen = NR::L2(delta);
- if (otherlen < 1e-18) return;
-
- me->pos = node->pos - (len / otherlen) * delta;
}
/**
/* we are either smooth or symm */
if (node->p.other == NULL) return;
-
if (node->n.other == NULL) return;
- if (node->code == NR_LINETO) {
- if (node->n.other->code == NR_LINETO) return;
+ if (sp_node_side_is_line(node, &node->p)) {
sp_node_adjust_handle(node, 1);
return;
}
- if (node->n.other->code == NR_LINETO) {
- if (node->code == NR_LINETO) return;
+ if (sp_node_side_is_line(node, &node->n)) {
sp_node_adjust_handle(node, -1);
return;
}
NR::Point c;
NR::Point pr;
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
n->subpath->nodepath->desktop->snapindicator->remove_snappoint();
- // If either (Shift and some handle retracted), or (we're already dragging out a handle)
+ // If either (Shift and some handle retracted), or (we're already dragging out a handle)
if ( (!n->subpath->nodepath->straight_path) &&
( ((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos)))
|| n->dragging_out ) )
// move the node to the closest point
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
n->origin[NR::X] + c[NR::X] - n->pos[NR::X],
- n->origin[NR::Y] + c[NR::Y] - n->pos[NR::Y]);
+ n->origin[NR::Y] + c[NR::Y] - n->pos[NR::Y],
+ true);
} else { // constraining to hor/vert
if (fabs((*p)[NR::X] - n->origin[NR::X]) > fabs((*p)[NR::Y] - n->origin[NR::Y])) { // snap to hor
- sp_nodepath_selected_nodes_move(n->subpath->nodepath, (*p)[NR::X] - n->pos[NR::X], n->origin[NR::Y] - n->pos[NR::Y]);
+ sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+ (*p)[NR::X] - n->pos[NR::X],
+ n->origin[NR::Y] - n->pos[NR::Y],
+ true,
+ true, Inkscape::Snapper::ConstraintLine(component_vectors[NR::X]));
} else { // snap to vert
- sp_nodepath_selected_nodes_move(n->subpath->nodepath, n->origin[NR::X] - n->pos[NR::X], (*p)[NR::Y] - n->pos[NR::Y]);
+ sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+ n->origin[NR::X] - n->pos[NR::X],
+ (*p)[NR::Y] - n->pos[NR::Y],
+ true,
+ true, Inkscape::Snapper::ConstraintLine(component_vectors[NR::Y]));
}
}
} else { // move freely
@@ -3568,30 +3771,34 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/,
g_assert_not_reached();
}
- NRPathcode const othercode = sp_node_path_code_from_side(n, opposite);
-
- SnapManager const &m = n->subpath->nodepath->desktop->namedview->snap_manager;
+ SPDesktop *desktop = n->subpath->nodepath->desktop;
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop, n->subpath->nodepath->item);
Inkscape::SnappedPoint s ;
- if (opposite->other && (n->type != Inkscape::NodePath::NODE_CUSP) && (othercode == NR_LINETO)) {
- /* We are smooth node adjacent with line */
- NR::Point const delta = *p - n->pos;
- NR::Coord const len = NR::L2(delta);
- Inkscape::NodePath::Node *othernode = opposite->other;
- NR::Point const ndelta = n->pos - othernode->pos;
- NR::Coord const linelen = NR::L2(ndelta);
- if (len > NR_EPSILON && linelen > NR_EPSILON) {
- NR::Coord const scal = dot(delta, ndelta) / linelen;
- (*p) = n->pos + (scal / linelen) * ndelta;
+
+ Inkscape::NodePath::Node *othernode = opposite->other;
+ if (othernode) {
+ if ((n->type != Inkscape::NodePath::NODE_CUSP) && sp_node_side_is_line(n, opposite)) {
+ /* We are smooth node adjacent with line */
+ NR::Point const delta = *p - n->pos;
+ NR::Coord const len = NR::L2(delta);
+ Inkscape::NodePath::Node *othernode = opposite->other;
+ NR::Point const ndelta = n->pos - othernode->pos;
+ NR::Coord const linelen = NR::L2(ndelta);
+ if (len > NR_EPSILON && linelen > NR_EPSILON) {
+ NR::Coord const scal = dot(delta, ndelta) / linelen;
+ (*p) = n->pos + (scal / linelen) * ndelta;
+ }
+ s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta));
+ } else {
+ s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p);
}
- s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item);
} else {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item);
+ s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p);
}
- *p = s.getPoint();
- if (s.getSnapped()) {
- n->subpath->nodepath->desktop->snapindicator->set_new_snappoint(s);
- }
-
+
+ s.getPoint(*p);
+
sp_node_adjust_handle(n, -which);
return FALSE;
@@ -3627,21 +3834,42 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
int const snaps = prefs_get_int_attribute("options.rotationsnapsperpi", "value", 12);
/* 0 interpreted as "no snapping". */
- // The closest PI/snaps angle, starting from zero.
- double const a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps);
- if (me->origin_radial.a == HUGE_VAL) {
- // ortho doesn't exist: original handle was zero length.
- rnew.a = a_snapped;
- } else {
- /* The closest PI/2 angle, starting from original angle (i.e. snapping to original,
- * its opposite and perpendiculars). */
+ // 1. Snap to the closest PI/snaps angle, starting from zero.
+ double a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps);
+
+ // 2. Snap to the original angle, its opposite and perpendiculars
+ if (me->origin_radial.a != HUGE_VAL) { // otherwise ortho doesn't exist: original handle was zero length
+ /* The closest PI/2 angle, starting from original angle */
double const a_ortho = me->origin_radial.a + floor((rnew.a - me->origin_radial.a)/(M_PI/2) + 0.5) * (M_PI/2);
// Snap to the closest.
- rnew.a = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a)
+ a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a)
? a_snapped
: a_ortho );
}
+
+ // 3. Snap to the angle of the opposite line, if any
+ Inkscape::NodePath::Node *othernode = other->other;
+ if (othernode) {
+ NR::Point other_to_snap(0,0);
+ if (sp_node_side_is_line(n, other)) {
+ other_to_snap = othernode->pos - n->pos;
+ } else {
+ other_to_snap = other->pos - n->pos;
+ }
+ if (NR::L2(other_to_snap) > 1e-3) {
+ Radial rother_to_snap(other_to_snap);
+ /* The closest PI/2 angle, starting from the angle of the opposite line segment */
+ double const a_oppo = rother_to_snap.a + floor((rnew.a - rother_to_snap.a)/(M_PI/2) + 0.5) * (M_PI/2);
+
+ // Snap to the closest.
+ a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_oppo - rnew.a)
+ ? a_snapped
+ : a_oppo );
+ }
+ }
+
+ rnew.a = a_snapped;
}
if (state & GDK_MOD1_MASK) {
@@ -3685,7 +3913,7 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
GString *length = SP_PX_TO_METRIC_STRING(rnew.r, desktop->namedview->getDefaultMetric());
- mc->setF(Inkscape::NORMAL_MESSAGE,
+ mc->setF(Inkscape::IMMEDIATE_MESSAGE,
_("<b>Node handle</b>: angle %0.2f°, length %s; with <b>Ctrl</b> to snap angle; with <b>Alt</b> to lock length; with <b>Shift</b> to rotate both handles"), degrees, length->str);
g_string_free(length, TRUE);
SPCurve *curve = NULL;
if (SP_IS_PATH(object)) {
SPCurve *curve_new = sp_path_get_curve_for_edit(SP_PATH(object));
- curve = sp_curve_copy(curve_new);
+ curve = curve_new->copy();
} else if ( IS_LIVEPATHEFFECT(object) && key) {
const gchar *svgd = object->repr->attribute(key);
if (svgd) {
- NArtBpath *bpath = sp_svg_read_path(svgd);
- SPCurve *curve_new = sp_curve_new_from_bpath(bpath);
+ Geom::PathVector pv = sp_svg_read_pathv(svgd);
+ SPCurve *curve_new = new SPCurve(pv);
if (curve_new) {
curve = curve_new; // don't do curve_copy because curve_new is already only created for us!
- } else {
- g_free(bpath);
}
}
}
} else if ( IS_LIVEPATHEFFECT(np->object) ) {
// FIXME: this writing to string and then reading from string is bound to be slow.
// create a method to convert from curve directly to 2geom...
- gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
+ gchar *svgpath = sp_svg_write_path( np->curve->get_pathvector() );
LIVEPATHEFFECT(np->object)->lpe->setParameter(np->repr_key, svgpath);
g_free(svgpath);
}
}
+SPCanvasItem *
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem *item, guint32 color = 0xff0000ff) {
+ SPCurve *flash_curve = curve->copy();
+ Geom::Matrix i2d = item ? sp_item_i2d_affine(item) : Geom::identity();
+ flash_curve->transform(i2d);
+ SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve);
+ // would be nice if its color could be XORed or something, now it is invisible for red stroked objects...
+ // unless we also flash the nodes...
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO);
+ sp_canvas_item_show(canvasitem);
+ flash_curve->unref();
+ return canvasitem;
+}
+
+SPCanvasItem *
+sp_nodepath_generate_helperpath(SPDesktop *desktop, SPPath *path) {
+ return sp_nodepath_generate_helperpath(desktop, sp_path_get_curve_for_edit(path), SP_ITEM(path),
+ prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff));
+}
+
void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
np->show_helperpath = show;
if (show) {
- SPCurve *helper_curve = sp_curve_copy(np->curve);
- sp_curve_transform(helper_curve, np->i2d );
+ SPCurve *helper_curve = np->curve->copy();
+ helper_curve->transform(np->i2d );
if (!np->helper_path) {
np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve);
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
} else {
sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
}
- sp_curve_unref(helper_curve);
+ helper_curve->unref();
} else {
if (np->helper_path) {
GtkObject *temp = np->helper_path;
}
}
-/* this function does not work yet */
+/* sp_nodepath_make_straight_path:
+ * Prevents user from curving the path by dragging a segment or activating handles etc.
+ * The resulting path is a linear interpolation between nodal points, with only straight segments.
+ * !!! this function does not work completely yet: it does not actively straighten the path, only prevents the path from being curved
+ */
void sp_nodepath_make_straight_path(Inkscape::NodePath::Path *np) {
np->straight_path = true;
np->show_handles = false;
g_message("add code to make the path straight.");
// do sp_nodepath_convert_node_type on all nodes?
- // search for this text !!! "Make selected segments lines"
+ // coding tip: search for this text : "Make selected segments lines"
}