void Inkscape::LineSnapper::constrainedSnap(SnappedConstraints &sc, Inkscape::SnapCandidatePoint const &p, Geom::OptRect const &/*bbox_to_snap*/, ConstraintLine const &c, std::vector<SPItem const *> const */*it*/) const { if (_snap_enabled == false || _snapmanager->snapprefs.getSnapFrom(p.getSourceType()) == false) { return; } /* Get the lines that we will try to snap to */ const LineList lines = _getSnapLines(p.getPoint()); for (LineList::const_iterator i = lines.begin(); i != lines.end(); i++) { if (Geom::L2(c.getDirection()) > 0) { // Can't do a constrained snap without a constraint // constraint line Geom::Point const point_on_line = c.hasPoint() ? c.getPoint() : p.getPoint(); Geom::Line line1(point_on_line, point_on_line + c.getDirection()); // grid/guide line Geom::Point const p1 = i->second; // point at guide/grid line Geom::Point const p2 = p1 + Geom::rot90(i->first); // 2nd point at guide/grid line Geom::Line line2(p1, p2); Geom::OptCrossing inters = Geom::OptCrossing(); // empty by default try { inters = Geom::intersection(line1, line2); } catch (Geom::InfiniteSolutions e) { // We're probably dealing with parallel lines, so snapping doesn't make any sense here continue; // jump to the next iterator in the for-loop } if (inters) { Geom::Point t = line1.pointAt((*inters).ta); const Geom::Coord dist = Geom::L2(t - p.getPoint()); if (dist < getSnapperTolerance()) { // When doing a constrained snap, we're already at an intersection. // This snappoint is therefore fully constrained, so there's no need // to look for additional intersections; just return the snapped point // and forget about the line _addSnappedPoint(sc, t, dist, p.getSourceType(), p.getSourceNum(), true); // For any line that's within range, we will also look at it's "point on line" p1. For guides // this point coincides with its origin; for grids this is of no use, but we cannot // discern between grids and guides here Geom::Coord const dist_p1 = Geom::L2(p1 - p.getPoint()); if (dist_p1 < getSnapperTolerance()) { _addSnappedLinesOrigin(sc, p1, dist_p1, p.getSourceType(), p.getSourceNum(), true); // Only relevant for guides; grids don't have an origin per line // Therefore _addSnappedLinesOrigin() will only be implemented for guides } } } } } }
Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint const &p, Inkscape::Snapper::SnapConstraint const &constraint, Geom::OptRect const &bbox_to_snap) const { // First project the mouse pointer onto the constraint Geom::Point pp = constraint.projection(p.getPoint()); Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(pp, p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, Geom::infinity(), 0, false, true, false); if (!someSnapperMightSnap()) { // Always return point on constraint return no_snap; } Inkscape::SnappedPoint result = no_snap; Inkscape::Preferences *prefs = Inkscape::Preferences::get(); if ((prefs->getBool("/options/snapmousepointer/value", false)) && p.isSingleHandle()) { // Snapping the mouse pointer instead of the constrained position of the knot allows // to snap to things which don't intersect with the constraint line; this is basically // then just a freesnap with the constraint applied afterwards // We'll only do this if we're dragging a single handle, and for example not when transforming an object in the selector tool result = freeSnap(p, bbox_to_snap); if (result.getSnapped()) { // only change the snap indicator if we really snapped to something if (_snapindicator && _desktop) { _desktop->snapindicator->set_new_snaptarget(result); } // Apply the constraint result.setPoint(constraint.projection(result.getPoint())); return result; } return no_snap; } IntermSnapResults isr; SnapperList const snappers = getSnappers(); for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); ++i) { (*i)->constrainedSnap(isr, p, bbox_to_snap, constraint, &_items_to_ignore, _unselected_nodes); } result = findBestSnap(p, isr, true); if (result.getSnapped()) { // only change the snap indicator if we really snapped to something if (_snapindicator && _desktop) { _desktop->snapindicator->set_new_snaptarget(result); } return result; } return no_snap; }
Inkscape::SnappedPoint SnapManager::constrainedAngularSnap(Inkscape::SnapCandidatePoint const &p, boost::optional<Geom::Point> const &p_ref, Geom::Point const &o, unsigned const snaps) const { Inkscape::SnappedPoint sp; if (snaps > 0) { // 0 means no angular snapping // p is at an arbitrary angle. Now we should snap this angle to specific increments. // For this we'll calculate the closest two angles, one at each side of the current angle Geom::Line y_axis(Geom::Point(0, 0), Geom::Point(0, 1)); Geom::Line p_line(o, p.getPoint()); double angle = Geom::angle_between(y_axis, p_line); double angle_incr = M_PI / snaps; double angle_offset = 0; if (p_ref) { Geom::Line p_line_ref(o, *p_ref); angle_offset = Geom::angle_between(y_axis, p_line_ref); } double angle_ceil = round_to_upper_multiple_plus(angle, angle_incr, angle_offset); double angle_floor = round_to_lower_multiple_plus(angle, angle_incr, angle_offset); // We have two angles now. The constrained snapper will try each of them and return the closest // Now do the snapping... std::vector<Inkscape::Snapper::SnapConstraint> constraints; constraints.push_back(Inkscape::Snapper::SnapConstraint(Geom::Line(o, angle_ceil - M_PI/2))); constraints.push_back(Inkscape::Snapper::SnapConstraint(Geom::Line(o, angle_floor - M_PI/2))); sp = multipleConstrainedSnaps(p, constraints); // Constraints will always be applied, even if we didn't snap if (!sp.getSnapped()) { // If we haven't snapped then we only had the constraint applied; sp.setTarget(Inkscape::SNAPTARGET_CONSTRAINED_ANGLE); } } else { sp = freeSnap(p); } return sp; }
/** * Mark the location of the snap source (not the snap target!) on the canvas by drawing a symbol. * * @param point_type Category of points to which the source point belongs: node, guide or bounding box * @param p The transformed position of the source point, paired with an identifier of the type of the snap source. */ void SnapManager::displaySnapsource(Inkscape::SnapCandidatePoint const &p) const { Inkscape::Preferences *prefs = Inkscape::Preferences::get(); if (prefs->getBool("/options/snapclosestonly/value")) { Inkscape::SnapSourceType t = p.getSourceType(); bool p_is_a_node = t & Inkscape::SNAPSOURCE_NODE_CATEGORY; bool p_is_a_bbox = t & Inkscape::SNAPSOURCE_BBOX_CATEGORY; bool p_is_other = (t & Inkscape::SNAPSOURCE_OTHERS_CATEGORY) || (t & Inkscape::SNAPSOURCE_DATUMS_CATEGORY); g_assert(_desktop != NULL); if (snapprefs.getSnapEnabledGlobally() && (p_is_other || (p_is_a_node && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_NODE_CATEGORY)) || (p_is_a_bbox && snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_BBOX_CATEGORY)))) { _desktop->snapindicator->set_new_snapsource(p); } else { _desktop->snapindicator->remove_snapsource(); } } }
void Inkscape::LineSnapper::freeSnap(SnappedConstraints &sc, Inkscape::SnapCandidatePoint const &p, Geom::OptRect const &/*bbox_to_snap*/, std::vector<SPItem const *> const */*it*/, std::vector<Inkscape::SnapCandidatePoint> */*unselected_nodes*/) const { if (!(_snap_enabled && _snapmanager->snapprefs.getSnapFrom(p.getSourceType())) ) { return; } /* Get the lines that we will try to snap to */ const LineList lines = _getSnapLines(p.getPoint()); for (LineList::const_iterator i = lines.begin(); i != lines.end(); i++) { Geom::Point const p1 = i->second; // point at guide/grid line Geom::Point const p2 = p1 + Geom::rot90(i->first); // 2nd point at guide/grid line // std::cout << " line through " << i->second << " with normal " << i->first; g_assert(i->first != Geom::Point(0,0)); // we cannot project on an linesegment of zero length Geom::Point const p_proj = Geom::projection(p.getPoint(), Geom::Line(p1, p2)); Geom::Coord const dist = Geom::L2(p_proj - p.getPoint()); //Store any line that's within snapping range if (dist < getSnapperTolerance()) { _addSnappedLine(sc, p_proj, dist, p.getSourceType(), p.getSourceNum(), i->first, i->second); // For any line that's within range, we will also look at it's "point on line" p1. For guides // this point coincides with its origin; for grids this is of no use, but we cannot // discern between grids and guides here Geom::Coord const dist_p1 = Geom::L2(p1 - p.getPoint()); if (dist_p1 < getSnapperTolerance()) { _addSnappedLinesOrigin(sc, p1, dist_p1, p.getSourceType(), p.getSourceNum(), false); // Only relevant for guides; grids don't have an origin per line // Therefore _addSnappedLinesOrigin() will only be implemented for guides } // std::cout << " -> distance = " << dist; } // std::cout << std::endl; } }
void Inkscape::LineSnapper::constrainedSnap(IntermSnapResults &isr, Inkscape::SnapCandidatePoint const &p, Geom::OptRect const &/*bbox_to_snap*/, SnapConstraint const &c, std::vector<SPItem const *> const */*it*/, std::vector<SnapCandidatePoint> */*unselected_nodes*/) const { if (_snap_enabled == false || _snapmanager->snapprefs.isSourceSnappable(p.getSourceType()) == false) { return; } // project the mouse pointer onto the constraint. Only the projected point will be considered for snapping Geom::Point pp = c.projection(p.getPoint()); /* Get the lines that we will try to snap to */ const LineList lines = _getSnapLines(pp); for (LineList::const_iterator i = lines.begin(); i != lines.end(); ++i) { Geom::Point const point_on_line = c.hasPoint() ? c.getPoint() : pp; Geom::Line gridguide_line(i->second, i->second + Geom::rot90(i->first)); if (c.isCircular()) { // Find the intersections between the line and the circular constraint // First, project the origin of the circle onto the line Geom::Point const origin = c.getPoint(); Geom::Point const p_proj = Geom::projection(origin, gridguide_line); Geom::Coord dist = Geom::L2(p_proj - origin); // distance from circle origin to constraint line Geom::Coord radius = c.getRadius(); if (dist == radius) { // Only one point of intersection; _addSnappedPoint(isr, p_proj, Geom::L2(pp - p_proj), p.getSourceType(), p.getSourceNum(), true); } else if (dist < radius) { // Two points of intersection, symmetrical with respect to the projected point // Calculate half the length of the linesegment between the two points of intersection Geom::Coord l = sqrt(radius*radius - dist*dist); Geom::Coord d = Geom::L2(gridguide_line.versor()); // length of versor, needed to normalize the versor if (d > 0) { Geom::Point v = l*gridguide_line.versor()/d; _addSnappedPoint(isr, p_proj + v, Geom::L2(p.getPoint() - (p_proj + v)), p.getSourceType(), p.getSourceNum(), true); _addSnappedPoint(isr, p_proj - v, Geom::L2(p.getPoint() - (p_proj - v)), p.getSourceType(), p.getSourceNum(), true); } } } else { // Find the intersections between the line and the linear constraint Geom::Line constraint_line(point_on_line, point_on_line + c.getDirection()); Geom::OptCrossing inters = Geom::OptCrossing(); // empty by default try { inters = Geom::intersection(constraint_line, gridguide_line); } catch (Geom::InfiniteSolutions &e) { // We're probably dealing with parallel lines, so snapping doesn't make any sense here continue; // jump to the next iterator in the for-loop } if (inters) { Geom::Point t = constraint_line.pointAt((*inters).ta); const Geom::Coord dist = Geom::L2(t - p.getPoint()); if (dist < getSnapperTolerance()) { // When doing a constrained snap, we're already at an intersection. // This snappoint is therefore fully constrained, so there's no need // to look for additional intersections; just return the snapped point // and forget about the line _addSnappedPoint(isr, t, dist, p.getSourceType(), p.getSourceNum(), true); } } } } }
void Inkscape::LineSnapper::freeSnap(IntermSnapResults &isr, Inkscape::SnapCandidatePoint const &p, Geom::OptRect const &/*bbox_to_snap*/, std::vector<SPItem const *> const */*it*/, std::vector<Inkscape::SnapCandidatePoint> */*unselected_nodes*/) const { if (!(_snap_enabled && _snapmanager->snapprefs.isSourceSnappable(p.getSourceType())) ) { return; } /* Get the lines that we will try to snap to */ const LineList lines = _getSnapLines(p.getPoint()); for (LineList::const_iterator i = lines.begin(); i != lines.end(); ++i) { Geom::Point const p1 = i->second; // point at guide/grid line Geom::Point const p2 = p1 + Geom::rot90(i->first); // 2nd point at guide/grid line // std::cout << " line through " << i->second << " with normal " << i->first; assert(i->first != Geom::Point(0,0)); // we cannot project on an linesegment of zero length Geom::Point const p_proj = Geom::projection(p.getPoint(), Geom::Line(p1, p2)); Geom::Coord const dist = Geom::L2(p_proj - p.getPoint()); //Store any line that's within snapping range if (dist < getSnapperTolerance()) { _addSnappedLine(isr, p_proj, dist, p.getSourceType(), p.getSourceNum(), i->first, i->second); // For any line that's within range, we will also look at it's "point on line" p1. For guides // this point coincides with its origin; for grids this is of no use, but we cannot // discern between grids and guides here Geom::Coord const dist_p1 = Geom::L2(p1 - p.getPoint()); if (dist_p1 < getSnapperTolerance()) { _addSnappedLinesOrigin(isr, p1, dist_p1, p.getSourceType(), p.getSourceNum(), false); // Only relevant for guides; grids don't have an origin per line // Therefore _addSnappedLinesOrigin() will only be implemented for guides } // Here we will try to snap either tangentially or perpendicularly to a grid/guide line // For this we need to know where the origin is located of the line that is currently being rotated, std::vector<std::pair<Geom::Point, bool> > const origins_and_vectors = p.getOriginsAndVectors(); // Now we will iterate over all the origins and vectors and see which of these will get use a tangential or perpendicular snap for (std::vector<std::pair<Geom::Point, bool> >::const_iterator it_origin_or_vector = origins_and_vectors.begin(); it_origin_or_vector != origins_and_vectors.end(); ++it_origin_or_vector) { if ((*it_origin_or_vector).second) { // if "second" is true then "first" is a vector, otherwise it's a point // When snapping a line with a constant vector (constant direction) to a guide or grid line, // then either all points will be perpendicular/tangential or none at all. This is not very useful continue; } //Geom::Point origin_doc = _snapmanager->getDesktop()->dt2doc((*it_origin_or_vector).first); // "first" contains a Geom::Point, denoting either a point Geom::Point origin = (*it_origin_or_vector).first; // "first" contains a Geom::Point, denoting either a point // We won't try to snap tangentially; a line being tangential to another line can be achieved by snapping both its endpoints // individually to the other line. There's no need to have an explicit tangential snap here, that would be redundant if (_snapmanager->snapprefs.getSnapPerp()) { // Find the point that leads to a perpendicular snap Geom::Point const origin_proj = Geom::projection(origin, Geom::Line(p1, p2)); Geom::Coord dist = Geom::L2(origin_proj - p.getPoint()); if (dist < getSnapperTolerance()) { _addSnappedLinePerpendicularly(isr, origin_proj, dist, p.getSourceType(), p.getSourceNum(), false); } } } // std::cout << " -> distance = " << dist; } // std::cout << std::endl; } }
Inkscape::SnappedPoint SnapManager::findBestSnap(Inkscape::SnapCandidatePoint const &p, IntermSnapResults const &isr, bool constrained, bool allowOffScreen, bool to_path_only) const { g_assert(_desktop != NULL); /* std::cout << "Type and number of snapped constraints: " << std::endl; std::cout << " Points : " << isr.points.size() << std::endl; std::cout << " Grid lines : " << isr.grid_lines.size()<< std::endl; std::cout << " Guide lines : " << isr.guide_lines.size()<< std::endl; std::cout << " Curves : " << isr.curves.size()<< std::endl; */ /* // Display all snap candidates on the canvas _desktop->snapindicator->remove_debugging_points(); for (std::list<Inkscape::SnappedPoint>::const_iterator i = isr.points.begin(); i != isr.points.end(); i++) { _desktop->snapindicator->set_new_debugging_point((*i).getPoint()); } for (std::list<Inkscape::SnappedCurve>::const_iterator i = isr.curves.begin(); i != isr.curves.end(); i++) { _desktop->snapindicator->set_new_debugging_point((*i).getPoint()); } for (std::list<Inkscape::SnappedLine>::const_iterator i = isr.grid_lines.begin(); i != isr.grid_lines.end(); i++) { _desktop->snapindicator->set_new_debugging_point((*i).getPoint()); } for (std::list<Inkscape::SnappedLine>::const_iterator i = isr.guide_lines.begin(); i != isr.guide_lines.end(); i++) { _desktop->snapindicator->set_new_debugging_point((*i).getPoint()); } */ // Store all snappoints std::list<Inkscape::SnappedPoint> sp_list; // search for the closest snapped point Inkscape::SnappedPoint closestPoint; if (getClosestSP(isr.points, closestPoint)) { sp_list.push_back(closestPoint); } // search for the closest snapped curve Inkscape::SnappedCurve closestCurve; // We might have collected the paths only to snap to their intersection, without the intention to snap to the paths themselves // Therefore we explicitly check whether the paths should be considered as snap targets themselves bool exclude_paths = !snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH); if (getClosestCurve(isr.curves, closestCurve, exclude_paths)) { sp_list.push_back(Inkscape::SnappedPoint(closestCurve)); } // search for the closest snapped grid line Inkscape::SnappedLine closestGridLine; if (getClosestSL(isr.grid_lines, closestGridLine)) { sp_list.push_back(Inkscape::SnappedPoint(closestGridLine)); } // search for the closest snapped guide line Inkscape::SnappedLine closestGuideLine; if (getClosestSL(isr.guide_lines, closestGuideLine)) { sp_list.push_back(Inkscape::SnappedPoint(closestGuideLine)); } // When freely snapping to a grid/guide/path, only one degree of freedom is eliminated // Therefore we will try get fully constrained by finding an intersection with another grid/guide/path // When doing a constrained snap however, we're already at an intersection of the constrained line and // the grid/guide/path we're snapping to. This snappoint is therefore fully constrained, so there's // no need to look for additional intersections if (!constrained) { if (snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_INTERSECTION)) { // search for the closest snapped intersection of curves Inkscape::SnappedPoint closestCurvesIntersection; if (getClosestIntersectionCS(isr.curves, p.getPoint(), closestCurvesIntersection, _desktop->dt2doc())) { closestCurvesIntersection.setSource(p.getSourceType()); sp_list.push_back(closestCurvesIntersection); } } if (snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_GUIDE_INTERSECTION)) { // search for the closest snapped intersection of a guide with a curve Inkscape::SnappedPoint closestCurveGuideIntersection; if (getClosestIntersectionCL(isr.curves, isr.guide_lines, p.getPoint(), closestCurveGuideIntersection, _desktop->dt2doc())) { closestCurveGuideIntersection.setSource(p.getSourceType()); sp_list.push_back(closestCurveGuideIntersection); } } // search for the closest snapped intersection of grid lines Inkscape::SnappedPoint closestGridPoint; if (getClosestIntersectionSL(isr.grid_lines, closestGridPoint)) { closestGridPoint.setSource(p.getSourceType()); closestGridPoint.setTarget(Inkscape::SNAPTARGET_GRID_INTERSECTION); sp_list.push_back(closestGridPoint); } // search for the closest snapped intersection of guide lines Inkscape::SnappedPoint closestGuidePoint; if (getClosestIntersectionSL(isr.guide_lines, closestGuidePoint)) { closestGuidePoint.setSource(p.getSourceType()); closestGuidePoint.setTarget(Inkscape::SNAPTARGET_GUIDE_INTERSECTION); sp_list.push_back(closestGuidePoint); } // search for the closest snapped intersection of grid with guide lines if (snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_GRID_GUIDE_INTERSECTION)) { Inkscape::SnappedPoint closestGridGuidePoint; if (getClosestIntersectionSL(isr.grid_lines, isr.guide_lines, closestGridGuidePoint)) { closestGridGuidePoint.setSource(p.getSourceType()); closestGridGuidePoint.setTarget(Inkscape::SNAPTARGET_GRID_GUIDE_INTERSECTION); sp_list.push_back(closestGridGuidePoint); } } } // Filter out all snap targets that do NOT include a path; this is useful when we try to insert // a node in a path (on doubleclick in the node tool). We don't want to change the shape of the // path, so the snapped point must be on a path, and not e.g. on a grid intersection if (to_path_only) { std::list<Inkscape::SnappedPoint>::iterator i = sp_list.begin(); while (i != sp_list.end()) { Inkscape::SnapTargetType t = (*i).getTarget(); if (t == Inkscape::SNAPTARGET_LINE_MIDPOINT || t == Inkscape::SNAPTARGET_PATH || t == Inkscape::SNAPTARGET_PATH_PERPENDICULAR || t == Inkscape::SNAPTARGET_PATH_TANGENTIAL || t == Inkscape::SNAPTARGET_PATH_INTERSECTION || t == Inkscape::SNAPTARGET_PATH_GUIDE_INTERSECTION || t == Inkscape::SNAPTARGET_PATH_CLIP || t == Inkscape::SNAPTARGET_PATH_MASK || t == Inkscape::SNAPTARGET_ELLIPSE_QUADRANT_POINT) { ++i; } else { i = sp_list.erase(i); } } } // now let's see which snapped point gets a thumbs up Inkscape::SnappedPoint bestSnappedPoint(p.getPoint()); // std::cout << "Finding the best snap..." << std::endl; for (std::list<Inkscape::SnappedPoint>::const_iterator i = sp_list.begin(); i != sp_list.end(); ++i) { // std::cout << "sp = " << (*i).getPoint() << " | source = " << (*i).getSource() << " | target = " << (*i).getTarget(); bool onScreen = _desktop->get_display_area().contains((*i).getPoint()); if (onScreen || allowOffScreen) { // Only snap to points which are not off the screen if ((*i).getSnapDistance() <= (*i).getTolerance()) { // Only snap to points within snapping range // if it's the first point, or if it is closer than the best snapped point so far if (i == sp_list.begin() || bestSnappedPoint.isOtherSnapBetter(*i, false)) { // then prefer this point over the previous one bestSnappedPoint = *i; } } } // std::cout << std::endl; } // Update the snap indicator, if requested if (_snapindicator) { if (bestSnappedPoint.getSnapped()) { _desktop->snapindicator->set_new_snaptarget(bestSnappedPoint); } else { _desktop->snapindicator->remove_snaptarget(); } } // std::cout << "findBestSnap = " << bestSnappedPoint.getPoint() << " | dist = " << bestSnappedPoint.getSnapDistance() << std::endl; return bestSnappedPoint; }
Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandidatePoint const &p, std::vector<Inkscape::Snapper::SnapConstraint> const &constraints, bool dont_snap, Geom::OptRect const &bbox_to_snap) const { Inkscape::SnappedPoint no_snap = Inkscape::SnappedPoint(p.getPoint(), p.getSourceType(), p.getSourceNum(), Inkscape::SNAPTARGET_CONSTRAINT, Geom::infinity(), 0, false, true, false); if (constraints.size() == 0) { return no_snap; } // We haven't tried to snap yet; we will first determine which constraint is closest to where we are now, // i.e. lets find out which of the constraints yields the closest projection of point p // Project the mouse pointer on each of the constraints std::vector<Geom::Point> projections; for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) { // Project the mouse pointer onto the constraint; In case we don't snap then we will // return the projection onto the constraint, such that the constraint is always enforced Geom::Point pp = (*c).projection(p.getPoint()); projections.push_back(pp); } // Select the closest constraint no_snap.setPoint(projections.front()); Inkscape::Snapper::SnapConstraint cc = constraints.front(); //closest constraint std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); std::vector<Geom::Point>::iterator pp = projections.begin(); for (; pp != projections.end(); ++pp) { if (Geom::L2(*pp - p.getPoint()) < Geom::L2(no_snap.getPoint() - p.getPoint())) { no_snap.setPoint(*pp); // Remember the projection onto the closest constraint cc = *c; // Remember the closest constraint itself } ++c; } if (!someSnapperMightSnap() || dont_snap) { return no_snap; } IntermSnapResults isr; SnapperList const snappers = getSnappers(); Inkscape::Preferences *prefs = Inkscape::Preferences::get(); bool snap_mouse = prefs->getBool("/options/snapmousepointer/value", false); Inkscape::SnappedPoint result = no_snap; if (snap_mouse && p.isSingleHandle()) { // Snapping the mouse pointer instead of the constrained position of the knot allows // to snap to things which don't intersect with the constraint line; this is basically // then just a freesnap with the constraint applied afterwards // We'll only to this if we're dragging a single handle, and for example not when transforming an object in the selector tool result = freeSnap(p, bbox_to_snap); // Now apply the constraint afterwards result.setPoint(cc.projection(result.getPoint())); } else { // Try to snap along the closest constraint for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); ++i) { (*i)->constrainedSnap(isr, p, bbox_to_snap, cc, &_items_to_ignore,_unselected_nodes); } result = findBestSnap(p, isr, true); } return result.getSnapped() ? result : no_snap; }