X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnodepath.cpp;h=82a5e841cae62eadbb67f5ed7641de0f2cbcaedc;hb=26b62dfb088a00b6debad350538a64c2af145f50;hp=1239f961bc2f399f149b650b34f36bb5852dc4cd;hpb=6c61d5ee45d84179713334a29ffda3f4aa029179;p=inkscape.git diff --git a/src/nodepath.cpp b/src/nodepath.cpp index 1239f961b..82a5e841c 100644 --- a/src/nodepath.cpp +++ b/src/nodepath.cpp @@ -19,10 +19,14 @@ #include "display/curve.h" #include "display/sp-ctrlline.h" #include "display/sodipodi-ctrl.h" +#include "display/sp-canvas-util.h" #include -#include "libnr/n-art-bpath.h" -#include "libnr/nr-path.h" +#include <2geom/pathvector.h> +#include <2geom/sbasis-to-bezier.h> +#include <2geom/bezier-curve.h> +#include <2geom/hvlinesegment.h> #include "helper/units.h" +#include "helper/geom.h" #include "knot.h" #include "inkscape.h" #include "document.h" @@ -41,15 +45,22 @@ #include "sp-metrics.h" #include "sp-path.h" #include "libnr/nr-matrix-ops.h" -#include "splivarot.h" #include "svg/svg.h" #include "verbs.h" #include "display/bezier-utils.h" #include #include +#include +#include +#include #include "live_effects/lpeobject.h" +#include "live_effects/lpeobject-reference.h" +#include "live_effects/effect.h" #include "live_effects/parameter/parameter.h" +#include "live_effects/parameter/path.h" #include "util/mathfns.h" +#include "display/snap-indicator.h" +#include "snapped-point.h" class NR::Matrix; @@ -89,8 +100,8 @@ static GMemChunk *nodechunk = NULL; /* 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 void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t); +static Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, guint length); /* Object updating */ @@ -146,6 +157,86 @@ 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 SPCanvasItem * +sp_nodepath_make_helper_item(Inkscape::NodePath::Path *np, /*SPDesktop *desktop, */const SPCurve *curve, bool show = false) { + SPCurve *helper_curve = curve->copy(); + helper_curve->transform(np->i2d); + SPCanvasItem *helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(helper_path), 0, SP_WIND_RULE_NONZERO); + sp_canvas_item_move_to_z(helper_path, 0); + if (show) { + sp_canvas_item_show(helper_path); + } + helper_curve->unref(); + return helper_path; +} + +static SPCanvasItem * +canvasitem_from_pathvec(Inkscape::NodePath::Path *np, Geom::PathVector const &pathv, bool show) { + SPCurve *helper_curve = new SPCurve(pathv); + return sp_nodepath_make_helper_item(np, helper_curve, show); +} + +static void +sp_nodepath_create_helperpaths(Inkscape::NodePath::Path *np) { + //std::map >* helper_path_vec; + if (!SP_IS_LPE_ITEM(np->item)) { + g_print ("Only LPEItems can have helperpaths!\n"); + return; + } + + SPLPEItem *lpeitem = SP_LPE_ITEM(np->item); + PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem); + for (PathEffectList::iterator i = lpelist.begin(); i != lpelist.end(); ++i) { + Inkscape::LivePathEffect::LPEObjectReference *lperef = (*i); + Inkscape::LivePathEffect::Effect *lpe = lperef->lpeobject->lpe; + // create new canvas items from the effect's helper paths + std::vector hpaths = lpe->getHelperPaths(lpeitem); + for (std::vector::iterator j = hpaths.begin(); j != hpaths.end(); ++j) { + (*np->helper_path_vec)[lpe].push_back(canvasitem_from_pathvec(np, *j, true)); + } + } +} + +void +sp_nodepath_update_helperpaths(Inkscape::NodePath::Path *np) { + //std::map >* helper_path_vec; + if (!SP_IS_LPE_ITEM(np->item)) { + g_print ("Only LPEItems can have helperpaths!\n"); + return; + } + + SPLPEItem *lpeitem = SP_LPE_ITEM(np->item); + PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem); + for (PathEffectList::iterator i = lpelist.begin(); i != lpelist.end(); ++i) { + Inkscape::LivePathEffect::Effect *lpe = (*i)->lpeobject->lpe; + /* update canvas items from the effect's helper paths; note that this code relies on the + * fact that getHelperPaths() will always return the same number of helperpaths in the same + * order as during their creation in sp_nodepath_create_helperpaths + */ + std::vector hpaths = lpe->getHelperPaths(lpeitem); + for (unsigned int j = 0; j < hpaths.size(); ++j) { + SPCurve *curve = new SPCurve(hpaths[j]); + curve->transform(np->i2d); + sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(((*np->helper_path_vec)[lpe])[j]), curve); + curve = curve->unref(); + } + } +} + +static void +sp_nodepath_destroy_helperpaths(Inkscape::NodePath::Path *np) { + for (HelperPathList::iterator i = np->helper_path_vec->begin(); i != np->helper_path_vec->end(); ++i) { + for (std::vector::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j) { + GtkObject *temp = *j; + *j = NULL; + gtk_object_destroy(temp); + } + } +} + + /** * \brief Creates new nodepath from item */ @@ -175,17 +266,15 @@ 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; - if (length == 0) { - sp_curve_unref(curve); + if (curve->get_segment_count() < 1) { + 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; } @@ -195,12 +284,20 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, np->subpaths = NULL; np->selected = NULL; np->shape_editor = NULL; //Let the shapeeditor that makes this set it - np->livarot_path = NULL; np->local_change = 0; np->show_handles = show_handles; np->helper_path = NULL; - np->curve = sp_curve_copy(curve); - np->show_helperpath = false; + np->helper_path_vec = new HelperPathList; + np->helperpath_rgba = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff); + np->helperpath_width = 1.0; + 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; @@ -222,51 +319,51 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, np->repr_nodetypes_key = g_strconcat(np->repr_key, "-nodetypes", NULL); Inkscape::LivePathEffect::Parameter *lpeparam = LIVEPATHEFFECT(object)->lpe->getParameter(repr_key_in); if (lpeparam) { - lpeparam->param_setup_notepath(np); + lpeparam->param_setup_nodepath(np); } } else { np->repr_nodetypes_key = g_strdup("sodipodi:nodetypes"); - if ( SP_SHAPE(np->object)->path_effect_href ) { + if ( sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object)) ) { np->repr_key = g_strdup("inkscape:original-d"); - LivePathEffectObject *lpeobj = sp_shape_get_livepatheffectobject(SP_SHAPE(np->object)); - if (lpeobj && lpeobj->lpe) { - lpeobj->lpe->setup_notepath(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"); } } + /* Calculate length of the nodetype string. The closing/starting point for closed paths is counted twice. + * So for example a closed rectangle has a nodetypestring of length 5. + * To get the correct count, one can count all segments in the paths, and then add the total number of (non-empty) paths. */ + Geom::PathVector pathv_sanitized = pathv_to_linear_and_cubic_beziers(np->curve->get_pathvector()); + np->curve->set_pathvector(pathv_sanitized); + guint length = np->curve->get_segment_count(); + for (Geom::PathVector::const_iterator pit = pathv_sanitized.begin(); pit != pathv_sanitized.end(); ++pit) { + length += pit->empty() ? 0 : 1; + } + 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)); - } + subpaths_from_pathvector(np, pathv_sanitized, 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); - - // create the livarot representation from the same item - sp_nodepath_ensure_livarot_path(np); + delete[] typestr; + curve->unref(); // 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_show(np->helper_path); - sp_curve_unref(helper_curve); + np->helper_path = sp_nodepath_make_helper_item(np, /*desktop, */np->curve, true); } + sp_nodepath_create_helperpaths(np); + return np; } @@ -288,18 +385,13 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) { g_assert(!np->selected); - if (np->livarot_path) { - delete np->livarot_path; - np->livarot_path = NULL; - } - if (np->helper_path) { GtkObject *temp = np->helper_path; np->helper_path = NULL; gtk_object_destroy(temp); } if (np->curve) { - sp_curve_unref(np->curve); + np->curve->unref(); np->curve = NULL; } @@ -312,27 +404,15 @@ void sp_nodepath_destroy(Inkscape::NodePath::Path *np) { np->repr_nodetypes_key = NULL; } + sp_nodepath_destroy_helperpaths(np); + delete np->helper_path_vec; + np->helper_path_vec = NULL; + np->desktop = NULL; g_free(np); } - -void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np) -{ - if (np && np->livarot_path == NULL) { - SPCurve *curve = create_curve(np); - NArtBpath *bpath = SP_CURVE_BPATH(curve); - np->livarot_path = bpath_to_Path(bpath); - - if (np->livarot_path) - np->livarot_path->ConvertWithBackData(0.01); - - sp_curve_unref(curve); - } -} - - /** * Return the node count of a given NodeSubPath. */ @@ -431,67 +511,71 @@ static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath) } /** - * 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 + * Create new nodepaths from pathvector, make it subpaths of np. + * \param t The node type array. */ -static NArtBpath *subpath_from_bpath(Inkscape::NodePath::Path *np, NArtBpath *b, gchar const *t) +static void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t) { - NR::Point ppos, pos, npos; - - g_assert((b->code == NR_MOVETO) || (b->code == NR_MOVETO_OPEN)); + 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 = pit->initialPoint() * (Geom::Matrix)np->i2d; + NRPathcode pcode = NR_MOVETO; + + /* Johan: Note that this is pretty arcane code. I am pretty sure it is working correctly, be very certain to change it! (better to just rewrite this whole method)*/ + for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit) { + if( dynamic_cast(&*cit) || + dynamic_cast(&*cit) || + dynamic_cast(&*cit) ) + { + NR::Point pos = cit->initialPoint() * (Geom::Matrix)np->i2d; + sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &pos); + + ppos = cit->finalPoint() * (Geom::Matrix)np->i2d; + pcode = NR_LINETO; + } + else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast(&*cit)) { + std::vector points = cubic_bezier->points(); + NR::Point pos = points[0] * (Geom::Matrix)np->i2d; + NR::Point npos = points[1] * (Geom::Matrix)np->i2d; + sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &npos); + + ppos = points[2] * (Geom::Matrix)np->i2d; + pcode = NR_CURVETO; + } + } - Inkscape::NodePath::SubPath *sp = sp_nodepath_subpath_new(np); - bool const closed = (b->code == NR_MOVETO); + 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 = closing_seg.finalPoint() * (Geom::Matrix)np->i2d; + sp_nodepath_node_new(sp, NULL, t[i++], NR_LINETO, &pos, &pos, &pos); + } - pos = NR::Point(b->x3, b->y3) * np->i2d; - if (b[1].code == NR_CURVETO) { - npos = NR::Point(b[1].x1, b[1].y1) * np->i2d; - } else { - npos = pos; - } - Inkscape::NodePath::Node *n; - n = sp_nodepath_node_new(sp, NULL, (Inkscape::NodePath::NodeType) *t, NR_MOVETO, &pos, &pos, &npos); - g_assert(sp->first == n); - g_assert(sp->last == n); - - b++; - t++; - while ((b->code == NR_CURVETO) || (b->code == NR_LINETO)) { - pos = NR::Point(b->x3, b->y3) * np->i2d; - if (b->code == NR_CURVETO) { - ppos = NR::Point(b->x2, b->y2) * np->i2d; - } else { - ppos = pos; + sp_nodepath_subpath_close(sp); } - if (b[1].code == NR_CURVETO) { - npos = NR::Point(b[1].x1, b[1].y1) * np->i2d; - } else { - npos = pos; - } - n = sp_nodepath_node_new(sp, NULL, (Inkscape::NodePath::NodeType)*t, b->code, &ppos, &pos, &npos); - b++; - t++; } - - if (closed) sp_nodepath_subpath_close(sp); - - return b; } /** - * Convert from sodipodi:nodetypes to new style type string. + * 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, guint 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; + guint pos = 0; if (types) { - for (gint i = 0; types[i] && ( i < length ); i++) { + for (guint i = 0; types[i] && ( i < length ); i++) { while ((types[i] > '\0') && (types[i] <= ' ')) i++; if (types[i] != '\0') { switch (types[i]) { @@ -525,17 +609,24 @@ static void update_object(Inkscape::NodePath::Path *np) { 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(); } + + // updating helperpaths of LPEItems is now done in sp_lpe_item_update(); + //sp_nodepath_update_helperpaths(np); + + // 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(); } /** @@ -547,11 +638,11 @@ static void update_repr_internal(Inkscape::NodePath::Path *np) 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 @@ -568,12 +659,15 @@ static void update_repr_internal(Inkscape::NodePath::Path *np) 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(); } - } + + // TODO: do we need this call here? after all, update_object() should have been called just before + //sp_nodepath_update_helperpaths(np); +} /** * Update XML path node with data from path object, commit changes forever. @@ -583,11 +677,6 @@ void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotati //fixme: np can be NULL, so check before proceeding g_return_if_fail(np != NULL); - if (np->livarot_path) { - delete np->livarot_path; - np->livarot_path = NULL; - } - update_repr_internal(np); sp_canvas_end_forced_full_redraws(np->desktop->canvas); @@ -600,11 +689,6 @@ void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotati */ static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key, const gchar *annotation) { - if (np->livarot_path) { - delete np->livarot_path; - np->livarot_path = NULL; - } - update_repr_internal(np); sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE, annotation); @@ -628,7 +712,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np) 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); @@ -644,7 +728,7 @@ static void stamp_repr(Inkscape::NodePath::Path *np) Inkscape::GC::release(new_repr); g_free(svgpath); g_free(typestr); - sp_curve_unref(curve); + curve->unref(); } /** @@ -652,22 +736,20 @@ static void stamp_repr(Inkscape::NodePath::Path *np) */ 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; @@ -682,7 +764,7 @@ static SPCurve *create_curve(Inkscape::NodePath::Path *np) } } if (sp->closed) { - sp_curve_closepath(curve); + curve->closepath(); } } @@ -868,17 +950,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; } } @@ -962,9 +1050,6 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N g_assert(node); g_assert(node->subpath); - if (type == static_cast(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; @@ -999,48 +1084,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 - NR::Point leg_prev = node->pos - node->p.other->pos; - NR::Point leg_next = node->pos - node->n.other->pos; + // convert both to curves: + node->code = NR_CURVETO; + node->n.other->code = NR_CURVETO; - double norm_leg_prev = L2(leg_prev); - double norm_leg_next = L2(leg_next); + NR::Point leg_prev = node->pos - node->p.other->pos; + NR::Point leg_next = node->pos - node->n.other->pos; - // 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(); - } + double norm_leg_prev = L2(leg_prev); + double norm_leg_next = L2(leg_next); + + 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); @@ -1090,23 +1284,56 @@ void sp_node_moveto(Inkscape::NodePath::Node *node, NR::Point p) * 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; - - if (snap) { - SnapManager const &m = nodepath->desktop->namedview->snap_manager; - + Inkscape::SnappedPoint best_abs; + + if (snap) { + /* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and + * not to itself. The snapper however can not tell which nodes are selected and which are not, so we + * must provide that information. */ + + // Build a list of the unselected nodes to which the snapper should snap + std::vector unselected_nodes; + for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) { + Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; + for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { + Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; + if (!node->selected) { + unselected_nodes.push_back(node->pos); + } + } + } + + SnapManager &m = nodepath->desktop->namedview->snap_manager; + for (GList *l = nodepath->selected; l != NULL; l = l->next) { Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item)); - 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; } } + + if (best_abs.getSnapped()) { + nodepath->desktop->snapindicator->set_new_snappoint(best_abs); + } else { + nodepath->desktop->snapindicator->remove_snappoint(); + } } for (GList *l = nodepath->selected; l != NULL; l = l->next) { @@ -1372,6 +1599,51 @@ sp_node_selected_move_screen(Inkscape::NodePath::Path *nodepath, gdouble dx, gdo } } +/** + * Move selected nodes to the absolute position given + */ +void sp_node_selected_move_absolute(Inkscape::NodePath::Path *nodepath, Geom::Coord val, Geom::Dim2 axis) +{ + for (GList *l = nodepath->selected; l != NULL; l = l->next) { + Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; + Geom::Point npos(axis == Geom::X ? val : n->pos[Geom::X], axis == Geom::Y ? val : n->pos[Geom::Y]); + sp_node_moveto(n, npos); + } + + sp_nodepath_update_repr(nodepath, _("Move nodes")); +} + +/** + * If the coordinates of all selected nodes coincide, return the common coordinate; otherwise return NR::Nothing + */ +boost::optional sp_node_selected_common_coord (Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis) +{ + boost::optional no_coord; + g_return_val_if_fail(nodepath->selected, no_coord); + + // determine coordinate of first selected node + GList *nsel = nodepath->selected; + Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nsel->data; + NR::Coord coord = n->pos[axis]; + bool coincide = true; + + // compare it to the coordinates of all the other selected nodes + for (GList *l = nsel->next; l != NULL; l = l->next) { + n = (Inkscape::NodePath::Node *) l->data; + if (n->pos[axis] != coord) { + coincide = false; + } + } + if (coincide) { + return coord; + } else { + Geom::Rect bbox = sp_node_selected_bbox(nodepath); + // currently we return the coordinate of the bounding box midpoint because I don't know how + // to erase the spin button entry field :), but maybe this can be useful behaviour anyway + return bbox.midpoint()[axis]; + } +} + /** If they don't yet exist, creates knot and line for the given side of the node */ static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side) { @@ -1421,11 +1693,11 @@ static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gb sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos); sp_knot_show(side->knot); } else { - if (side->knot->pos != side->pos) { // only if it's really moved + if (side->knot->pos != to_2geom(side->pos)) { // only if it's really moved if (fire_move_signals) { - sp_knot_set_position(side->knot, &side->pos, 0); // this will set coords of the line as well + sp_knot_set_position(side->knot, side->pos, 0); // this will set coords of the line as well } else { - sp_knot_moveto(side->knot, &side->pos); + sp_knot_moveto(side->knot, side->pos); sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos); } } @@ -1460,11 +1732,11 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov sp_knot_show(node->knot); } - if (node->knot->pos != node->pos) { // visible knot is in a different position, need to update + if (node->knot->pos != to_2geom(node->pos)) { // visible knot is in a different position, need to update if (fire_move_signals) - sp_knot_set_position(node->knot, &node->pos, 0); + sp_knot_set_position(node->knot, node->pos, 0); else - sp_knot_moveto(node->knot, &node->pos); + sp_knot_moveto(node->knot, node->pos); } gboolean show_handles = node->selected; @@ -1664,15 +1936,23 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po return; } - sp_nodepath_ensure_livarot_path(nodepath); - NR::Maybe maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p); - if (!maybe_position) { - return; + SPCurve *curve = create_curve(nodepath); // perhaps we can use nodepath->curve here instead? + Geom::PathVector const &pathv = curve->get_pathvector(); + Geom::PathVectorPosition pvpos = Geom::nearestPoint(pathv, p); + + // calculate index for nodepath's representation. + unsigned int segment_index = floor(pvpos.t) + 1; + for (unsigned int i = 0; i < pvpos.path_nr; ++i) { + segment_index += pathv[i].size() + 1; + if (pathv[i].closed()) { + segment_index += 1; + } } - Path::cut_position position = *maybe_position; + + curve->unref(); //find segment to segment - Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece); + Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(segment_index); //fixme: this can return NULL, so check before proceeding. g_return_if_fail(e != NULL); @@ -1700,21 +1980,32 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p) return; } - sp_nodepath_ensure_livarot_path(nodepath); - NR::Maybe maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p); - if (!maybe_position) { - return; + SPCurve *curve = create_curve(nodepath); // perhaps we can use nodepath->curve here instead? + Geom::PathVector const &pathv = curve->get_pathvector(); + Geom::PathVectorPosition pvpos = Geom::nearestPoint(pathv, p); + + // calculate index for nodepath's representation. + double int_part; + double t = std::modf(pvpos.t, &int_part); + unsigned int segment_index = (unsigned int)int_part + 1; + for (unsigned int i = 0; i < pvpos.path_nr; ++i) { + segment_index += pathv[i].size() + 1; + if (pathv[i].closed()) { + segment_index += 1; + } } - Path::cut_position position = *maybe_position; + + curve->unref(); //find segment to split - Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece); + Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(segment_index); //don't know why but t seems to flip for lines if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1)) == NR_LINETO) { - position.t = 1.0 - position.t; + t = 1.0 - t; } - Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(e, position.t); + + Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(e, t); sp_nodepath_node_select(n, FALSE, TRUE); /* fixme: adjust ? */ @@ -1784,13 +2075,15 @@ void sp_node_selected_break(Inkscape::NodePath::Path *nodepath) { 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); @@ -1834,40 +2127,20 @@ void sp_node_selected_duplicate(Inkscape::NodePath::Path *nodepath) } /** - * Join two nodes by merging them into one. + * Internal function to join two nodes by merging them into one. */ -void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) +static void do_node_selected_join(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b) { - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - if (g_list_length(nodepath->selected) != 2) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); - return; - } - - Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data; - Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data; - - g_assert(a != b); - if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) { - // someone tried to join an orphan node (i.e. a single-node subpath). - // this is not worth an error message, just fail silently. - return; - } - - if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); - return; - } - /* a and b are endpoints */ + // if one of the two nodes is mouseovered, fix its position NR::Point c; if (a->knot && SP_KNOT_IS_MOUSEOVER(a->knot)) { c = a->pos; } else if (b->knot && SP_KNOT_IS_MOUSEOVER(b->knot)) { c = b->pos; } else { + // otherwise, move joined node to the midpoint c = (a->pos + b->pos) / 2; } @@ -1882,26 +2155,33 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) } /* a and b are separate subpaths */ - Inkscape::NodePath::SubPath *sa = a->subpath; - Inkscape::NodePath::SubPath *sb = b->subpath; + Inkscape::NodePath::SubPath *sa = a->subpath; + Inkscape::NodePath::SubPath *sb = b->subpath; NR::Point p; - Inkscape::NodePath::Node *n; + Inkscape::NodePath::Node *n; NRPathcode code; if (a == sa->first) { + // we will now reverse sa, so that a is its last node, not first, and drop that node p = sa->first->n.pos; code = (NRPathcode)sa->first->n.other->code; + // create new subpath Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(sa->nodepath); + // create a first moveto node on it n = sa->last; sp_nodepath_node_new(t, NULL,Inkscape::NodePath::NODE_CUSP, NR_MOVETO, &n->n.pos, &n->pos, &n->p.pos); n = n->p.other; + if (n == sa->first) n = NULL; while (n) { + // copy the rest of the nodes from sa to t, going backwards sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); n = n->p.other; if (n == sa->first) n = NULL; } + // replace sa with t sp_nodepath_subpath_destroy(sa); sa = t; } else if (a == sa->last) { + // a is already last, just drop it p = sa->last->p.pos; code = (NRPathcode)sa->last->code; sp_nodepath_node_destroy(sa->last); @@ -1911,11 +2191,13 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) } if (b == sb->first) { + // copy all nodes from b to a, forward sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->first->n.pos); for (n = sb->first->n.other; n != NULL; n = n->n.other) { sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos); } } else if (b == sb->last) { + // copy all nodes from b to a, backward sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->last->p.pos); for (n = sb->last->p.other; n != NULL; n = n->p.other) { sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); @@ -1935,32 +2217,10 @@ void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) } /** - * Join two nodes by adding a segment between them. + * Internal function to join two nodes by adding a segment between them. */ -void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath) +static void do_node_selected_join_segment(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b) { - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - if (g_list_length(nodepath->selected) != 2) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); - return; - } - - Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data; - Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data; - - g_assert(a != b); - if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) { - // someone tried to join an orphan node (i.e. a single-node subpath). - // this is not worth an error message, just fail silently. - return; - } - - if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); - return; - } - if (a->subpath == b->subpath) { Inkscape::NodePath::SubPath *sp = a->subpath; @@ -1984,10 +2244,10 @@ void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath) } /* a and b are separate subpaths */ - Inkscape::NodePath::SubPath *sa = a->subpath; - Inkscape::NodePath::SubPath *sb = b->subpath; + Inkscape::NodePath::SubPath *sa = a->subpath; + Inkscape::NodePath::SubPath *sb = b->subpath; - Inkscape::NodePath::Node *n; + Inkscape::NodePath::Node *n; NR::Point p; NRPathcode code; if (a == sa->first) { @@ -2035,6 +2295,61 @@ void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath) sp_nodepath_update_repr(nodepath, _("Join nodes by segment")); } +enum NodeJoinType { NODE_JOIN_ENDPOINTS, NODE_JOIN_SEGMENT }; + +/** + * Internal function to handle joining two nodes. + */ +static void node_do_selected_join(Inkscape::NodePath::Path *nodepath, NodeJoinType mode) +{ + if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses + + if (g_list_length(nodepath->selected) != 2) { + nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); + return; + } + + Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data; + Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data; + + g_assert(a != b); + if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) { + // someone tried to join an orphan node (i.e. a single-node subpath). + // this is not worth an error message, just fail silently. + return; + } + + if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) { + nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); + return; + } + + switch(mode) { + case NODE_JOIN_ENDPOINTS: + do_node_selected_join(nodepath, a, b); + break; + case NODE_JOIN_SEGMENT: + do_node_selected_join_segment(nodepath, a, b); + break; + } +} + +/** + * Join two nodes by merging them into one. + */ +void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) +{ + node_do_selected_join(nodepath, NODE_JOIN_ENDPOINTS); +} + +/** + * Join two nodes by adding a segment between them. + */ +void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath) +{ + node_do_selected_join(nodepath, NODE_JOIN_SEGMENT); +} + /** * Delete one or more selected nodes and preserve the shape of the path as much as possible. */ @@ -2117,8 +2432,10 @@ void sp_node_delete_preserve(GList *nodes_to_delete) //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]; @@ -2867,53 +3184,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; @@ -2921,19 +3226,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; } /** @@ -2948,17 +3251,14 @@ static void sp_node_adjust_handles(Inkscape::NodePath::Node *node) /* 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; } @@ -3204,9 +3504,11 @@ node_request(SPKnot */*knot*/, NR::Point *p, guint state, gpointer data) 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 ) ) @@ -3350,14 +3652,23 @@ node_request(SPKnot */*knot*/, NR::Point *p, guint state, gpointer data) // 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 @@ -3434,10 +3745,10 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data) // forget origin and set knot position once more (because it can be wrong now due to restrictions) if (n->p.knot == knot) { n->p.origin_radial.a = 0; - sp_knot_set_position(knot, &n->p.pos, state); + sp_knot_set_position(knot, n->p.pos, state); } else if (n->n.knot == knot) { n->n.origin_radial.a = 0; - sp_knot_set_position(knot, &n->n.pos, state); + sp_knot_set_position(knot, n->n.pos, state); } else { g_assert_not_reached(); } @@ -3448,7 +3759,7 @@ static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data) /** * Node handle "request" signal callback. */ -static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/, gpointer data) +static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data) { Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; @@ -3468,26 +3779,46 @@ 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; - - 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; + SPDesktop *desktop = n->subpath->nodepath->desktop; + SnapManager &m = desktop->namedview->snap_manager; + m.setup(desktop, n->subpath->nodepath->item); + Inkscape::SnappedPoint s; + + if ((state & GDK_SHIFT_MASK) != 0) { + // We will not try to snap when the shift-key is pressed + // so remove the old snap indicator and don't wait for it to time-out + desktop->snapindicator->remove_snappoint(); + } + + 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; + } + if ((state & GDK_SHIFT_MASK) == 0) { + s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta)); + } + } else { + if ((state & GDK_SHIFT_MASK) == 0) { + s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p); + } } - *p = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item).getPoint(); } else { - *p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item).getPoint(); + if ((state & GDK_SHIFT_MASK) == 0) { + s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p); + } } - + + s.getPoint(*p); + sp_node_adjust_handle(n, -which); return FALSE; @@ -3523,21 +3854,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) { @@ -3552,7 +3904,7 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer other->pos = NR::Point(rother) + n->pos; if (other->knot) { sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos); - sp_knot_moveto(other->knot, &other->pos); + sp_knot_moveto(other->knot, other->pos); } } @@ -3561,7 +3913,7 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer // move knot, but without emitting the signal: // we cannot emit a "moved" signal because we're now processing it - sp_knot_moveto(me->knot, &(me->pos)); + sp_knot_moveto(me->knot, me->pos); update_object(n->subpath->nodepath); @@ -3581,7 +3933,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, _("Node handle: angle %0.2f°, length %s; with Ctrl to snap angle; with Alt to lock length; with Shift to rotate both handles"), degrees, length->str); g_string_free(length, TRUE); @@ -3919,7 +4271,7 @@ void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, /** * Flip selected nodes horizontally/vertically. */ -void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Maybe center) +void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, boost::optional center) { if (!nodepath || !nodepath->selected) return; @@ -3933,13 +4285,7 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma } else { // scale nodes as an "object": - Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data; - NR::Rect box (n0->pos, n0->pos); // originally includes the first selected node - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - box.expandTo (n->pos); // contain all selected nodes - } - + Geom::Rect box = sp_node_selected_bbox (nodepath); if (!center) { center = box.midpoint(); } @@ -3960,6 +4306,19 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma sp_nodepath_update_repr(nodepath, _("Flip nodes")); } +Geom::Rect sp_node_selected_bbox (Inkscape::NodePath::Path *nodepath) +{ + g_assert (nodepath->selected); + + Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data; + Geom::Rect box (n0->pos, n0->pos); // originally includes the first selected node + for (GList *l = nodepath->selected; l != NULL; l = l->next) { + Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; + box.expandTo (n->pos); // contain all selected nodes + } + return box; +} + //----------------------------------------------- /** * Return new subpath under given nodepath. @@ -4114,7 +4473,7 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node * n->n.other = next; n->knot = sp_knot_new(sp->nodepath->desktop, _("Node: drag to edit the path; with Ctrl to snap to horizontal/vertical; with Ctrl+Alt to snap to handles' directions")); - sp_knot_set_position(n->knot, pos, 0); + sp_knot_set_position(n->knot, *pos, 0); n->knot->setShape ((n->type == Inkscape::NodePath::NODE_CUSP)? SP_KNOT_SHAPE_DIAMOND : SP_KNOT_SHAPE_SQUARE); n->knot->setSize ((n->type == Inkscape::NodePath::NODE_CUSP)? 9 : 7); @@ -4392,6 +4751,8 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to Sha Inkscape::MessageContext *mc = SP_NODE_CONTEXT (ec)->_node_message_context; if (!mc) return; + inkscape_active_desktop()->emitToolSubselectionChanged(NULL); + if (selected_nodes == 0) { Inkscape::Selection *sel = desktop->selection; if (!sel || sel->isEmpty()) { @@ -4445,16 +4806,14 @@ SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key) { 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); } } } @@ -4467,36 +4826,107 @@ void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) { return; if (SP_IS_PATH(np->object)) { - if (SP_SHAPE(np->object)->path_effect_href) { + if (sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object))) { sp_path_set_original_curve(SP_PATH(np->object), curve, true, false); } else { sp_shape_set_curve(SP_SHAPE(np->object), curve, true); } } 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)); - LIVEPATHEFFECT(np->object)->lpe->setParameter(np->repr_key, svgpath); - g_free(svgpath); - - np->object->requestModified(SP_OBJECT_MODIFIED_FLAG); + Inkscape::LivePathEffect::PathParam *pathparam = dynamic_cast( LIVEPATHEFFECT(np->object)->lpe->getParameter(np->repr_key) ); + if (pathparam) { + pathparam->set_new_value(np->curve->get_pathvector(), false); // do not write to SVG + np->object->requestModified(SP_OBJECT_MODIFIED_FLAG); + } } } +/** +SPCanvasItem * +sp_nodepath_path_to_canvasitem(Inkscape::NodePath::Path *np, SPPath *path) { + return sp_nodepath_make_helper_item(np, sp_path_get_curve_for_edit(path)); +} +**/ + +/** +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)); +} +**/ + +SPCanvasItem * +sp_nodepath_helperpath_from_path(SPDesktop *desktop, SPPath *path) { + SPCurve *flash_curve = sp_path_get_curve_for_edit(path)->copy(); + Geom::Matrix i2d = sp_item_i2d_affine(SP_ITEM(path)); + 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... + guint32 color = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff); + 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; +} + +// TODO: Merge this with sp_nodepath_make_helper_item()! void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) { np->show_helperpath = show; + + if (show) { + SPCurve *helper_curve = np->curve->copy(); + helper_curve->transform(np->i2d); + if (!np->helper_path) { + //np->helper_path = sp_nodepath_make_helper_item(np, desktop, helper_curve, true); // Caution: this applies the transform np->i2d twice!! + + 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); + 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); + } else { + sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); + } + helper_curve->unref(); + } else { + if (np->helper_path) { + GtkObject *temp = np->helper_path; + np->helper_path = NULL; + gtk_object_destroy(temp); + } + } } -/* 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" } - /* Local Variables: mode:c++