diff options
Diffstat (limited to 'src/object-snapper.cpp')
| -rw-r--r-- | src/object-snapper.cpp | 867 |
1 files changed, 867 insertions, 0 deletions
diff --git a/src/object-snapper.cpp b/src/object-snapper.cpp new file mode 100644 index 0000000..f72436b --- /dev/null +++ b/src/object-snapper.cpp @@ -0,0 +1,867 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * Snapping things to objects. + * + * Authors: + * Carl Hetherington <inkscape@carlh.net> + * Diederik van Lierop <mail@diedenrezi.nl> + * Jon A. Cruz <jon@joncruz.org> + * Abhishek Sharma + * + * Copyright (C) 2005 - 2012 Authors + * + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +#include <2geom/circle.h> +#include <2geom/line.h> +#include <2geom/path-intersection.h> +#include <2geom/path-sink.h> +#include <memory> + +#include "desktop.h" +#include "display/curve.h" +#include "document.h" +#include "inkscape.h" +#include "live_effects/effect-enum.h" +#include "object/sp-clippath.h" +#include "object/sp-flowtext.h" +#include "object/sp-image.h" +#include "object/sp-item-group.h" +#include "object/sp-mask.h" +#include "object/sp-namedview.h" +#include "object/sp-path.h" +#include "object/sp-page.h" +#include "object/sp-root.h" +#include "object/sp-shape.h" +#include "object/sp-text.h" +#include "object/sp-use.h" +#include "path/path-util.h" // curve_for_item +#include "preferences.h" +#include "snap-enums.h" +#include "style.h" +#include "svg/svg.h" +#include "text-editing.h" +#include "page-manager.h" + +Inkscape::ObjectSnapper::ObjectSnapper(SnapManager *sm, Geom::Coord const d) + : Snapper(sm, d) +{ + _points_to_snap_to = std::make_unique<std::vector<SnapCandidatePoint>>(); + _paths_to_snap_to = std::make_unique<std::vector<SnapCandidatePath>>(); +} + +Inkscape::ObjectSnapper::~ObjectSnapper() +{ + _points_to_snap_to->clear(); + _clear_paths(); +} + +Geom::Coord Inkscape::ObjectSnapper::getSnapperTolerance() const +{ + SPDesktop const *dt = _snapmanager->getDesktop(); + double const zoom = dt ? dt->current_zoom() : 1; + return _snapmanager->snapprefs.getObjectTolerance() / zoom; +} + +bool Inkscape::ObjectSnapper::getSnapperAlwaysSnap() const +{ + return _snapmanager->snapprefs.getObjectTolerance() == 10000; //TODO: Replace this threshold of 10000 by a constant; see also tolerance-slider.cpp +} + +void Inkscape::ObjectSnapper::_collectNodes(SnapSourceType const &t, + bool const &first_point) const +{ + // Now, let's first collect all points to snap to. If we have a whole bunch of points to snap, + // e.g. when translating an item using the selector tool, then we will only do this for the + // first point and store the collection for later use. This significantly improves the performance + if (first_point) { + _points_to_snap_to->clear(); + + // Determine the type of bounding box we should snap to + SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX; + + bool p_is_a_node = t & SNAPSOURCE_NODE_CATEGORY; + bool p_is_a_bbox = t & SNAPSOURCE_BBOX_CATEGORY; + bool p_is_other = (t & SNAPSOURCE_OTHERS_CATEGORY) || (t & SNAPSOURCE_DATUMS_CATEGORY); + + // A point considered for snapping should be either a node, a bbox corner or a guide/other. Pick only ONE! + if (((p_is_a_node && p_is_a_bbox) || (p_is_a_bbox && p_is_other) || (p_is_a_node && p_is_other))) { + g_warning("Snap warning: node type is ambiguous"); + } + + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_CORNER, SNAPTARGET_BBOX_EDGE_MIDPOINT, SNAPTARGET_BBOX_MIDPOINT)) { + Preferences *prefs = Preferences::get(); + bool prefs_bbox = prefs->getBool("/tools/bounding_box"); + bbox_type = !prefs_bbox ? + SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; + } + + // Consider the page border for snapping to + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PAGE_CORNER)) { + if (auto document = _snapmanager->getDocument()) { + auto ignore_page = _snapmanager->getPageToIgnore(); + for (auto page : document->getPageManager().getPages()) { + if (ignore_page == page) + continue; + getBBoxPoints(page->getDesktopRect(), _points_to_snap_to.get(), true, + SNAPSOURCE_PAGE_CORNER, SNAPTARGET_PAGE_CORNER, + SNAPSOURCE_UNDEFINED, SNAPTARGET_UNDEFINED, // No edges + SNAPSOURCE_PAGE_CENTER, SNAPTARGET_PAGE_CENTER); + } + // Only the corners get added here. + getBBoxPoints(document->preferredBounds(), _points_to_snap_to.get(), false, + SNAPSOURCE_UNDEFINED, SNAPTARGET_PAGE_CORNER, + SNAPSOURCE_UNDEFINED, SNAPTARGET_UNDEFINED, + SNAPSOURCE_UNDEFINED, SNAPTARGET_UNDEFINED); + } + } + + for (const auto & _candidate : *_snapmanager->_obj_snapper_candidates) { + //Geom::Affine i2doc(Geom::identity()); + SPItem *root_item = _candidate.item; + + SPUse *use = dynamic_cast<SPUse *>(_candidate.item); + if (use) { + root_item = use->root(); + } + g_return_if_fail(root_item); + + //Collect all nodes so we can snap to them + if (p_is_a_node || p_is_other || (p_is_a_bbox && !_snapmanager->snapprefs.getStrictSnapping())) { + // Note: there are two ways in which intersections are considered: + // Method 1: Intersections are calculated for each shape individually, for both the + // snap source and snap target (see sp_shape_snappoints) + // Method 2: Intersections are calculated for each curve or line that we've snapped to, i.e. only for + // the target (see the intersect() method in the SnappedCurve and SnappedLine classes) + // Some differences: + // - Method 1 doesn't find intersections within a set of multiple objects + // - Method 2 only works for targets + // When considering intersections as snap targets: + // - Method 1 only works when snapping to nodes, whereas + // - Method 2 only works when snapping to paths + // - There will be performance differences too! + // If both methods are being used simultaneously, then this might lead to duplicate targets! + + // Well, here we will be looking for snap TARGETS. Both methods can therefore be used. + // When snapping to paths, we will get a collection of snapped lines and snapped curves. findBestSnap() will + // go hunting for intersections (but only when asked to in the prefs of course). In that case we can just + // temporarily block the intersections in sp_item_snappoints, we don't need duplicates. If we're not snapping to + // paths though but only to item nodes then we should still look for the intersections in sp_item_snappoints() + bool old_pref = _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH_INTERSECTION); + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH)) { + // So if we snap to paths, then findBestSnap will find the intersections + // and therefore we temporarily disable SNAPTARGET_PATH_INTERSECTION, which will + // avoid root_item->getSnappoints() below from returning intersections + _snapmanager->snapprefs.setTargetSnappable(SNAPTARGET_PATH_INTERSECTION, false); + } + + // We should not snap a transformation center to any of the centers of the items in the + // current selection (see the comment in SelTrans::centerRequest()) + bool old_pref2 = _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_ROTATION_CENTER); + if (old_pref2) { + std::vector<SPItem*> rotationSource=_snapmanager->getRotationCenterSource(); + for (auto itemlist : rotationSource) { + if (_candidate.item == itemlist) { + // don't snap to this item's rotation center + _snapmanager->snapprefs.setTargetSnappable(SNAPTARGET_ROTATION_CENTER, false); + break; + } + } + } + + root_item->getSnappoints(*_points_to_snap_to, &_snapmanager->snapprefs); + + // restore the original snap preferences + _snapmanager->snapprefs.setTargetSnappable(SNAPTARGET_PATH_INTERSECTION, old_pref); + _snapmanager->snapprefs.setTargetSnappable(SNAPTARGET_ROTATION_CENTER, old_pref2); + } + + //Collect the bounding box's corners so we can snap to them + if (p_is_a_bbox || (!_snapmanager->snapprefs.getStrictSnapping() && p_is_a_node) || p_is_other) { + // Discard the bbox of a clipped path / mask, because we don't want to snap to both the bbox + // of the item AND the bbox of the clipping path at the same time + if (!_candidate.clip_or_mask) { + Geom::OptRect b = root_item->desktopBounds(bbox_type); + getBBoxPoints(b, _points_to_snap_to.get(), true, + _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_CORNER), + _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_EDGE_MIDPOINT), + _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_MIDPOINT)); + } + } + } + } +} + +void Inkscape::ObjectSnapper::_snapNodes(IntermSnapResults &isr, + SnapCandidatePoint const &p, + std::vector<SnapCandidatePoint> *unselected_nodes, + SnapConstraint const &c, + Geom::Point const &p_proj_on_constraint) const +{ + // Iterate through all nodes, find out which one is the closest to p, and snap to it! + + _collectNodes(p.getSourceType(), p.getSourceNum() <= 0); + + if (unselected_nodes != nullptr && unselected_nodes->size() > 0) { + g_assert(_points_to_snap_to != nullptr); + _points_to_snap_to->insert(_points_to_snap_to->end(), unselected_nodes->begin(), unselected_nodes->end()); + } + + SnappedPoint s; + bool success = false; + bool strict_snapping = _snapmanager->snapprefs.getStrictSnapping(); + + for (const auto & k : *_points_to_snap_to) { + if (_allowSourceToSnapToTarget(p.getSourceType(), k.getTargetType(), strict_snapping)) { + Geom::Point target_pt = k.getPoint(); + Geom::Coord dist = Geom::L2(target_pt - p.getPoint()); // Default: free (unconstrained) snapping + if (!c.isUndefined()) { + // We're snapping to nodes along a constraint only, so find out if this node + // is at the constraint, while allowing for a small margin + if (Geom::L2(target_pt - c.projection(target_pt)) > 1e-9) { + // The distance from the target point to its projection on the constraint + // is too large, so this point is not on the constraint. Skip it! + continue; + } + dist = Geom::L2(target_pt - p_proj_on_constraint); + } + + if (dist < getSnapperTolerance() && dist < s.getSnapDistance()) { + s = SnappedPoint(target_pt, p.getSourceType(), p.getSourceNum(), k.getTargetType(), dist, getSnapperTolerance(), getSnapperAlwaysSnap(), false, true, k.getTargetBBox()); + success = true; + } + } + } + + if (success) { + isr.points.push_back(s); + } +} + +void Inkscape::ObjectSnapper::_snapTranslatingGuide(IntermSnapResults &isr, + Geom::Point const &p, + Geom::Point const &guide_normal) const +{ + // Iterate through all nodes, find out which one is the closest to this guide, and snap to it! + _collectNodes(SNAPSOURCE_GUIDE, true); + + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION, SNAPTARGET_BBOX_EDGE, SNAPTARGET_PAGE_BORDER, SNAPTARGET_TEXT_BASELINE)) { + _collectPaths(p, SNAPSOURCE_GUIDE, true); + _snapPaths(isr, SnapCandidatePoint(p, SNAPSOURCE_GUIDE), nullptr, nullptr); + } + + SnappedPoint s; + + Geom::Coord tol = getSnapperTolerance(); + + for (const auto & k : *_points_to_snap_to) { + Geom::Point target_pt = k.getPoint(); + // Project each node (*k) on the guide line (running through point p) + Geom::Point p_proj = Geom::projection(target_pt, Geom::Line(p, p + Geom::rot90(guide_normal))); + Geom::Coord dist = Geom::L2(target_pt - p_proj); // distance from node to the guide + Geom::Coord dist2 = Geom::L2(p - p_proj); // distance from projection of node on the guide, to the mouse location + if ((dist < tol && dist2 < tol) || getSnapperAlwaysSnap()) { + s = SnappedPoint(target_pt, SNAPSOURCE_GUIDE, 0, k.getTargetType(), dist, tol, getSnapperAlwaysSnap(), false, true, k.getTargetBBox()); + isr.points.push_back(s); + } + } +} + + +/// @todo investigate why Geom::Point p is passed in but ignored. +void Inkscape::ObjectSnapper::_collectPaths(Geom::Point /*p*/, + SnapSourceType const source_type, + bool const &first_point) const +{ + // Now, let's first collect all paths to snap to. If we have a whole bunch of points to snap, + // e.g. when translating an item using the selector tool, then we will only do this for the + // first point and store the collection for later use. This significantly improves the performance + if (first_point) { + _clear_paths(); + + // Determine the type of bounding box we should snap to + SPItem::BBoxType bbox_type = SPItem::GEOMETRIC_BBOX; + + bool p_is_a_node = source_type & SNAPSOURCE_NODE_CATEGORY; + bool p_is_a_bbox = source_type & SNAPSOURCE_BBOX_CATEGORY; + bool p_is_other = (source_type & SNAPSOURCE_OTHERS_CATEGORY) || (source_type & SNAPSOURCE_DATUMS_CATEGORY); + + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_EDGE)) { + Preferences *prefs = Preferences::get(); + int prefs_bbox = prefs->getBool("/tools/bounding_box", false); + bbox_type = !prefs_bbox ? + SPItem::VISUAL_BBOX : SPItem::GEOMETRIC_BBOX; + } + + // Consider the page border for snapping + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PAGE_BORDER) && _snapmanager->snapprefs.isAnyCategorySnappable()) { + Geom::PathVector *border_path = _getBorderPathv(); + if (border_path != nullptr) { + _paths_to_snap_to->push_back(SnapCandidatePath(border_path, SNAPTARGET_PAGE_BORDER, Geom::OptRect())); + } + } + + for (const auto & _candidate : *_snapmanager->_obj_snapper_candidates) { + + /* Transform the requested snap point to this item's coordinates */ + Geom::Affine i2doc(Geom::identity()); + SPItem *root_item = nullptr; + /* We might have a clone at hand, so make sure we get the root item */ + SPUse *use = dynamic_cast<SPUse *>(_candidate.item); + if (use) { + i2doc = use->get_root_transform(); + root_item = use->root(); + g_return_if_fail(root_item); + } else { + i2doc = _candidate.item->i2doc_affine(); + root_item = _candidate.item; + } + + //Build a list of all paths considered for snapping to + + //Add the item's path to snap to + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION, SNAPTARGET_TEXT_BASELINE)) { + if (p_is_other || p_is_a_node || (!_snapmanager->snapprefs.getStrictSnapping() && p_is_a_bbox)) { + if (dynamic_cast<SPText *>(root_item) || dynamic_cast<SPFlowtext *>(root_item)) { + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_TEXT_BASELINE)) { + // Snap to the text baseline + Text::Layout const *layout = te_get_layout(static_cast<SPItem *>(root_item)); + if (layout != nullptr && layout->outputExists()) { + Geom::PathVector *pv = new Geom::PathVector(); + pv->push_back(layout->baseline() * root_item->i2dt_affine() * _candidate.additional_affine * _snapmanager->getDesktop()->doc2dt()); + _paths_to_snap_to->push_back(SnapCandidatePath(pv, SNAPTARGET_TEXT_BASELINE, Geom::OptRect())); + } + } + } else { + // Snapping for example to a traced bitmap is very stressing for + // the CPU, so we'll only snap to paths having no more than 500 nodes + // This also leads to a lag of approx. 500 msec (in my lousy test set-up). + bool very_complex_path = false; + SPPath *path = dynamic_cast<SPPath *>(root_item); + if (path) { + very_complex_path = path->nodesInPath() > 500; + } + + if (!very_complex_path && root_item && _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION)) { + std::unique_ptr<SPCurve> curve; + SPShape *shape = dynamic_cast<SPShape *>(root_item); + if (shape) { + curve = SPCurve::copy(shape->curve()); + }/* else if (dynamic_cast<SPText *>(root_item) || dynamic_cast<SPFlowtext *>(root_item)) { + curve = te_get_layout(root_item)->convertToCurves(); + }*/ + if (curve) { + // We will get our own copy of the pathvector, which must be freed at some point + Geom::PathVector *pv = new Geom::PathVector(curve->get_pathvector()); + (*pv) *= root_item->i2dt_affine() * _candidate.additional_affine * _snapmanager->getDesktop()->doc2dt(); // (_edit_transform * _i2d_transform); + + _paths_to_snap_to->push_back(SnapCandidatePath(pv, SNAPTARGET_PATH, Geom::OptRect())); // Perhaps for speed, get a reference to the Geom::pathvector, and store the transformation besides it. + } + } + } + } + } + + //Add the item's bounding box to snap to + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_BBOX_EDGE)) { + if (p_is_other || p_is_a_bbox || (!_snapmanager->snapprefs.getStrictSnapping() && p_is_a_node)) { + // Discard the bbox of a clipped path / mask, because we don't want to snap to both the bbox + // of the item AND the bbox of the clipping path at the same time + if (!_candidate.clip_or_mask) { + Geom::OptRect rect = root_item->bounds(bbox_type, i2doc); + if (rect) { + Geom::PathVector *path = _getPathvFromRect(*rect); + rect = root_item->desktopBounds(bbox_type); + _paths_to_snap_to->push_back(SnapCandidatePath(path, SNAPTARGET_BBOX_EDGE, rect)); + } + } + } + } + } + } +} + +void Inkscape::ObjectSnapper::_snapPaths(IntermSnapResults &isr, + SnapCandidatePoint const &p, + std::vector<SnapCandidatePoint> *unselected_nodes, + SPPath const *selected_path) const +{ + _collectPaths(p.getPoint(), p.getSourceType(), p.getSourceNum() <= 0); + // Now we can finally do the real snapping, using the paths collected above + + SPDesktop const *dt = _snapmanager->getDesktop(); + g_assert(dt != nullptr); + Geom::Point const p_doc = dt->dt2doc(p.getPoint()); + + bool const node_tool_active = _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION) && selected_path != nullptr; + + if (p.getSourceNum() <= 0) { + /* findCandidates() is used for snapping to both paths and nodes. It ignores the path that is + * currently being edited, because that path requires special care: when snapping to nodes + * only the unselected nodes of that path should be considered, and these will be passed on separately. + * This path must not be ignored however when snapping to the paths, so we add it here + * manually when applicable. + * */ + if (node_tool_active) { + // TODO fix the function to be const correct: + auto curve = curve_for_item(const_cast<SPPath *>(selected_path)); + if (curve) { + Geom::PathVector *pathv = new Geom::PathVector(curve->get_pathvector()); // Must be freed. + *pathv *= selected_path->i2doc_affine(); + _paths_to_snap_to->push_back(SnapCandidatePath(pathv, SNAPTARGET_PATH, Geom::OptRect(), true)); + } + } + } + + int num_path = 0; // _paths_to_snap_to contains multiple path_vectors, each containing multiple paths. + // num_path will count the paths, and will not be zeroed for each path_vector. It will + // continue counting + + bool strict_snapping = _snapmanager->snapprefs.getStrictSnapping(); + bool snap_perp = _snapmanager->snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_PERPENDICULAR); + bool snap_tang = _snapmanager->snapprefs.isTargetSnappable(Inkscape::SNAPTARGET_PATH_TANGENTIAL); + + //dt->snapindicator->remove_debugging_points(); + for (const auto & it_p : *_paths_to_snap_to) { + if (_allowSourceToSnapToTarget(p.getSourceType(), it_p.target_type, strict_snapping)) { + bool const being_edited = node_tool_active && it_p.currently_being_edited; + //if true then this pathvector it_pv is currently being edited in the node tool + + for(Geom::PathVector::iterator it_pv = (it_p.path_vector)->begin(); it_pv != (it_p.path_vector)->end(); ++it_pv) { + // Find a nearest point for each curve within this path + // n curves will return n time values with 0 <= t <= 1 + std::vector<double> anp = (*it_pv).nearestTimePerCurve(p_doc); + + //std::cout << "#nearest points = " << anp.size() << " | p = " << p.getPoint() << std::endl; + // Now we will examine each of the nearest points, and determine whether it's within snapping range and if we should snap to it + std::vector<double>::const_iterator np = anp.begin(); + unsigned int index = 0; + for (; np != anp.end(); ++np, index++) { + Geom::Curve const *curve = &(it_pv->at(index)); + Geom::Point const sp_doc = curve->pointAt(*np); + //dt->snapindicator->set_new_debugging_point(sp_doc*dt->doc2dt()); + bool c1 = true; + bool c2 = true; + if (being_edited) { + /* If the path is being edited, then we should only snap though to stationary pieces of the path + * and not to the pieces that are being dragged around. This way we avoid + * self-snapping. For this we check whether the nodes at both ends of the current + * piece are unselected; if they are then this piece must be stationary + */ + g_assert(unselected_nodes != nullptr); + Geom::Point start_pt = dt->doc2dt(curve->pointAt(0)); + Geom::Point end_pt = dt->doc2dt(curve->pointAt(1)); + c1 = isUnselectedNode(start_pt, unselected_nodes); + c2 = isUnselectedNode(end_pt, unselected_nodes); + /* Unfortunately, this might yield false positives for coincident nodes. Inkscape might therefore mistakenly + * snap to path segments that are not stationary. There are at least two possible ways to overcome this: + * - Linking the individual nodes of the SPPath we have here, to the nodes of the NodePath::SubPath class as being + * used in sp_nodepath_selected_nodes_move. This class has a member variable called "selected". For this the nodes + * should be in the exact same order for both classes, so we can index them + * - Replacing the SPPath being used here by the NodePath::SubPath class; but how? + */ + } + + Geom::Point const sp_dt = dt->doc2dt(sp_doc); + if (!being_edited || (c1 && c2)) { + Geom::Coord dist = Geom::distance(sp_doc, p_doc); + // std::cout << " dist -> " << dist << std::endl; + if (dist < getSnapperTolerance()) { + // Add the curve we have snapped to + Geom::Point sp_tangent_dt = Geom::Point(0,0); + if (p.getSourceType() == Inkscape::SNAPSOURCE_GUIDE_ORIGIN) { + // We currently only use the tangent when snapping guides, so only in this case we will + // actually calculate the tangent to avoid wasting CPU cycles + Geom::Point sp_tangent_doc = curve->unitTangentAt(*np); + sp_tangent_dt = dt->doc2dt(sp_tangent_doc) - dt->doc2dt(Geom::Point(0,0)); + } + isr.curves.emplace_back(sp_dt, sp_tangent_dt, num_path, index, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), false, curve, p.getSourceType(), p.getSourceNum(), it_p.target_type, it_p.target_bbox); + if (snap_tang || snap_perp) { + // For each curve that's within snapping range, we will now also search for tangential and perpendicular snaps + _snapPathsTangPerp(snap_tang, snap_perp, isr, p, curve, dt); + } + } + } + } + num_path++; + } // End of: for (Geom::PathVector::iterator ....) + } + } +} + +/* Returns true if point is coincident with one of the unselected nodes */ +bool Inkscape::ObjectSnapper::isUnselectedNode(Geom::Point const &point, std::vector<SnapCandidatePoint> const *unselected_nodes) const +{ + if (unselected_nodes == nullptr) { + return false; + } + + if (unselected_nodes->size() == 0) { + return false; + } + + for (const auto & unselected_node : *unselected_nodes) { + if (Geom::L2(point - unselected_node.getPoint()) < 1e-4) { + return true; + } + } + + return false; +} + +void Inkscape::ObjectSnapper::_snapPathsConstrained(IntermSnapResults &isr, + SnapCandidatePoint const &p, + SnapConstraint const &c, + Geom::Point const &p_proj_on_constraint, + std::vector<SnapCandidatePoint> *unselected_nodes, + SPPath const *selected_path) const +{ + + _collectPaths(p_proj_on_constraint, p.getSourceType(), p.getSourceNum() <= 0); + + // Now we can finally do the real snapping, using the paths collected above + + SPDesktop const *dt = _snapmanager->getDesktop(); + g_assert(dt != nullptr); + + Geom::Point direction_vector = c.getDirection(); + if (!is_zero(direction_vector)) { + direction_vector = Geom::unit_vector(direction_vector); + } + + // The intersection point of the constraint line with any path, must lie within two points on the + // SnapConstraint: p_min_on_cl and p_max_on_cl. The distance between those points is twice the snapping tolerance + Geom::Point const p_min_on_cl = dt->dt2doc(p_proj_on_constraint - getSnapperTolerance() * direction_vector); + Geom::Point const p_max_on_cl = dt->dt2doc(p_proj_on_constraint + getSnapperTolerance() * direction_vector); + Geom::Coord tolerance = getSnapperTolerance(); + + // PS: Because the paths we're about to snap to are all expressed relative to document coordinate system, we will have + // to convert the snapper coordinates from the desktop coordinates to document coordinates + + Geom::PathVector constraint_path; + if (c.isCircular()) { + Geom::Circle constraint_circle(dt->dt2doc(c.getPoint()), c.getRadius()); + Geom::PathBuilder pb; + pb.feed(constraint_circle); + pb.flush(); + constraint_path = pb.peek(); + } else { + Geom::Path constraint_line; + constraint_line.start(p_min_on_cl); + constraint_line.appendNew<Geom::LineSegment>(p_max_on_cl); + constraint_path.push_back(constraint_line); + } + + bool const node_tool_active = _snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION) && selected_path != nullptr; + + //TODO: code duplication + if (p.getSourceNum() <= 0) { + /* findCandidates() is used for snapping to both paths and nodes. It ignores the path that is + * currently being edited, because that path requires special care: when snapping to nodes + * only the unselected nodes of that path should be considered, and these will be passed on separately. + * This path must not be ignored however when snapping to the paths, so we add it here + * manually when applicable. + * */ + if (node_tool_active) { + // TODO fix the function to be const correct: + auto curve = curve_for_item(const_cast<SPPath *>(selected_path)); + if (curve) { + Geom::PathVector *pathv = new Geom::PathVector(curve->get_pathvector()); // Must be freed. + *pathv *= selected_path->i2doc_affine(); + _paths_to_snap_to->push_back(SnapCandidatePath(pathv, SNAPTARGET_PATH, Geom::OptRect(), true)); + } + } + } + + bool strict_snapping = _snapmanager->snapprefs.getStrictSnapping(); + + // Find all intersections of the constrained path with the snap target candidates + for (const auto & k : *_paths_to_snap_to) { + if (k.path_vector && _allowSourceToSnapToTarget(p.getSourceType(), k.target_type, strict_snapping)) { + // Do the intersection math + std::vector<Geom::PVIntersection> inters = constraint_path.intersect(*(k.path_vector)); + + bool const being_edited = node_tool_active && k.currently_being_edited; + + // Convert the collected intersections to snapped points + for (const auto & inter : inters) { + int index = inter.second.path_index; // index on the second path, which is the target path that we snapped to + Geom::Curve const *curve = &(k.path_vector->at(index).at(inter.second.curve_index)); + + bool c1 = true; + bool c2 = true; + //TODO: Remove code duplication, see _snapPaths; it's documented in detail there + if (being_edited) { + g_assert(unselected_nodes != nullptr); + Geom::Point start_pt = dt->doc2dt(curve->pointAt(0)); + Geom::Point end_pt = dt->doc2dt(curve->pointAt(1)); + c1 = isUnselectedNode(start_pt, unselected_nodes); + c2 = isUnselectedNode(end_pt, unselected_nodes); + } + + if (!being_edited || (c1 && c2)) { + // Convert to desktop coordinates + Geom::Point p_inters = dt->doc2dt(inter.point()); + // Construct a snapped point + Geom::Coord dist = Geom::L2(p.getPoint() - p_inters); + SnappedPoint s = SnappedPoint(p_inters, p.getSourceType(), p.getSourceNum(), k.target_type, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), true, false, k.target_bbox); + // Store the snapped point + if (dist <= tolerance) { // If the intersection is within snapping range, then we might snap to it + isr.points.push_back(s); + } + } + } + } + } +} + + +void Inkscape::ObjectSnapper::freeSnap(IntermSnapResults &isr, + SnapCandidatePoint const &p, + Geom::OptRect const &bbox_to_snap, + std::vector<SPObject const *> const *it, + std::vector<SnapCandidatePoint> *unselected_nodes) const +{ + if (_snap_enabled == false || _snapmanager->snapprefs.isSourceSnappable(p.getSourceType()) == false || ThisSnapperMightSnap() == false) { + return; + } + + /* Get a list of all the SPItems that we will try to snap to; this only needs to be done for some snappers, and + not for the grid snappers, so we'll do this here and not in the Snapmanager::freeSnap(). This saves us from wasting + precious CPU cycles */ + if (p.getSourceNum() <= 0) { + Geom::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : Geom::Rect(p.getPoint(), p.getPoint()); + _snapmanager->_findCandidates(_snapmanager->getDocument()->getRoot(), it, local_bbox_to_snap, false, Geom::identity()); + } + + _snapNodes(isr, p, unselected_nodes); + + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION, SNAPTARGET_BBOX_EDGE, SNAPTARGET_PAGE_BORDER, SNAPTARGET_TEXT_BASELINE)) { + unsigned n = (unselected_nodes == nullptr) ? 0 : unselected_nodes->size(); + if (n > 0) { + /* While editing a path in the node tool, findCandidates must ignore that path because + * of the node snapping requirements (i.e. only unselected nodes must be snapable). + * That path must not be ignored however when snapping to the paths, so we add it here + * manually when applicable + */ + SPPath const *path = nullptr; + if (it != nullptr) { + SPPath const *tmpPath = dynamic_cast<SPPath const *>(*it->begin()); + if ((it->size() == 1) && tmpPath) { + path = tmpPath; + } // else: *it->begin() might be a SPGroup, e.g. when editing a LPE of text that has been converted to a group of paths + // as reported in bug #356743. In that case we can just ignore it, i.e. not snap to this item + } + _snapPaths(isr, p, unselected_nodes, path); + } else { + _snapPaths(isr, p, nullptr, nullptr); + } + } +} + +void Inkscape::ObjectSnapper::constrainedSnap( IntermSnapResults &isr, + SnapCandidatePoint const &p, + Geom::OptRect const &bbox_to_snap, + SnapConstraint const &c, + std::vector<SPObject const *> const *it, + std::vector<SnapCandidatePoint> *unselected_nodes) const +{ + if (_snap_enabled == false || _snapmanager->snapprefs.isSourceSnappable(p.getSourceType()) == false || ThisSnapperMightSnap() == 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 a list of all the SPItems that we will try to snap to; this only needs to be done for some snappers, and + not for the grid snappers, so we'll do this here and not in the Snapmanager::freeSnap(). This saves us from wasting + precious CPU cycles */ + if (p.getSourceNum() <= 0) { + Geom::Rect const local_bbox_to_snap = bbox_to_snap ? *bbox_to_snap : Geom::Rect(pp, pp); // Using the projected point here! Not so in freeSnap()! + _snapmanager->_findCandidates(_snapmanager->getDocument()->getRoot(), it, local_bbox_to_snap, false, Geom::identity()); + } + + // A constrained snap, is a snap in only one degree of freedom (specified by the constraint line). + // This is useful for example when scaling an object while maintaining a fixed aspect ratio. Its + // nodes are only allowed to move in one direction (i.e. in one degree of freedom). + + _snapNodes(isr, p, unselected_nodes, c, pp); + + if (_snapmanager->snapprefs.isTargetSnappable(SNAPTARGET_PATH, SNAPTARGET_PATH_INTERSECTION, SNAPTARGET_BBOX_EDGE, SNAPTARGET_PAGE_BORDER, SNAPTARGET_TEXT_BASELINE)) { + //TODO: Remove code duplication; see freeSnap() + unsigned n = (unselected_nodes == nullptr) ? 0 : unselected_nodes->size(); + if (n > 0) { + /* While editing a path in the node tool, findCandidates must ignore that path because + * of the node snapping requirements (i.e. only unselected nodes must be snapable). + * That path must not be ignored however when snapping to the paths, so we add it here + * manually when applicable + */ + SPPath const *path = nullptr; + if (it != nullptr) { + SPPath const *tmpPath = dynamic_cast<SPPath const *>(*it->begin()); + if ((it->size() == 1) && tmpPath) { + path = tmpPath; + } // else: *it->begin() might be a SPGroup, e.g. when editing a LPE of text that has been converted to a group of paths + // as reported in bug #356743. In that case we can just ignore it, i.e. not snap to this item + } + _snapPathsConstrained(isr, p, c, pp, unselected_nodes, path); + } else { + _snapPathsConstrained(isr, p, c, pp, nullptr, nullptr); + } + } +} + +bool Inkscape::ObjectSnapper::ThisSnapperMightSnap() const +{ + return true; +} + +void Inkscape::ObjectSnapper::_clear_paths() const +{ + for (const auto & k : *_paths_to_snap_to) { + delete k.path_vector; + } + _paths_to_snap_to->clear(); +} + +Geom::PathVector* Inkscape::ObjectSnapper::_getBorderPathv() const +{ + Geom::Rect const border_rect = Geom::Rect(Geom::Point(0,0), Geom::Point((_snapmanager->getDocument())->getWidth().value("px"),(_snapmanager->getDocument())->getHeight().value("px"))); + return _getPathvFromRect(border_rect); +} + +Geom::PathVector* Inkscape::ObjectSnapper::_getPathvFromRect(Geom::Rect const rect) const +{ + auto const border_curve = SPCurve::new_from_rect(rect, true); + if (border_curve) { + Geom::PathVector *dummy = new Geom::PathVector(border_curve->get_pathvector()); + return dummy; + } else { + return nullptr; + } +} + +/** + * Default version of the getBBoxPoints with default corner source types. + */ +void Inkscape::getBBoxPoints(Geom::OptRect const bbox, + std::vector<SnapCandidatePoint> *points, + bool const isTarget, + bool const corners, + bool const edges, + bool const midpoint) +{ + getBBoxPoints(bbox, points, isTarget, + corners ? SNAPSOURCE_BBOX_CORNER : SNAPSOURCE_UNDEFINED, + corners ? SNAPTARGET_BBOX_CORNER : SNAPTARGET_UNDEFINED, + edges ? SNAPSOURCE_BBOX_EDGE_MIDPOINT : SNAPSOURCE_UNDEFINED, + edges ? SNAPTARGET_BBOX_EDGE_MIDPOINT : SNAPTARGET_UNDEFINED, + midpoint ? SNAPSOURCE_BBOX_MIDPOINT : SNAPSOURCE_UNDEFINED, + midpoint ? SNAPTARGET_BBOX_MIDPOINT : SNAPTARGET_UNDEFINED); +} + +void Inkscape::getBBoxPoints(Geom::OptRect const bbox, + std::vector<SnapCandidatePoint> *points, + bool const /*isTarget*/, + Inkscape::SnapSourceType corner_src, + Inkscape::SnapTargetType corner_tgt, + Inkscape::SnapSourceType edge_src, + Inkscape::SnapTargetType edge_tgt, + Inkscape::SnapSourceType mid_src, + Inkscape::SnapTargetType mid_tgt) +{ + if (bbox) { + // collect the corners of the bounding box + for ( unsigned k = 0 ; k < 4 ; k++ ) { + if (corner_src || corner_tgt) { + points->push_back(SnapCandidatePoint(bbox->corner(k), corner_src, -1, corner_tgt, *bbox)); + } + // optionally, collect the midpoints of the bounding box's edges too + if (edge_src || edge_tgt) { + points->push_back(SnapCandidatePoint((bbox->corner(k) + bbox->corner((k+1) % 4))/2, edge_src, -1, edge_tgt, *bbox)); + } + } + if (mid_src || mid_tgt) { + points->push_back(SnapCandidatePoint(bbox->midpoint(), mid_src, -1, mid_tgt, *bbox)); + } + } +} + +bool Inkscape::ObjectSnapper::_allowSourceToSnapToTarget(SnapSourceType source, SnapTargetType target, bool strict_snapping) const +{ + bool allow_this_pair_to_snap = true; + + if (strict_snapping) { // bounding boxes will not snap to nodes/paths and vice versa + if (((source & SNAPSOURCE_BBOX_CATEGORY) && (target & SNAPTARGET_NODE_CATEGORY)) || + ((source & SNAPSOURCE_NODE_CATEGORY) && (target & SNAPTARGET_BBOX_CATEGORY))) { + allow_this_pair_to_snap = false; + } + } + + return allow_this_pair_to_snap; +} + +void Inkscape::ObjectSnapper::_snapPathsTangPerp(bool snap_tang, bool snap_perp, IntermSnapResults &isr, SnapCandidatePoint const &p, Geom::Curve const *curve, SPDesktop const *dt) const +{ + // Here we will try to snap either tangentially or perpendicularly to a single path; for this we need to know where the origin is located of the line that is currently being rotated, + // or we need to know the vector of the guide which is currently being translated + 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 (const auto & origins_and_vector : origins_and_vectors) { + Geom::Point origin_or_vector_doc = dt->dt2doc(origins_and_vector.first); // "first" contains a Geom::Point, denoting either a point or vector + if (origins_and_vector.second) { // if "second" is true then "first" is a vector, otherwise it's a point + // So we have a vector, which tells us what tangential or perpendicular direction we're looking for + if (curve->degreesOfFreedom() <= 2) { // A LineSegment has order one, and therefore 2 DOF + // When snapping to a point of a line segment that has a specific tangential or normal vector, then either all point + // along that line will be snapped to or no points at all will be snapped to. This is not very useful, so let's skip + // any line segments and lets only snap to higher order curves + continue; + } + // The vector is being treated as a point (relative to the origin), and has been translated to document coordinates accordingly + // We need however to make it a vector again, because also the origin has been transformed + origin_or_vector_doc -= dt->dt2doc(Geom::Point(0,0)); + } + + Geom::Point point_dt; + Geom::Coord dist; + std::vector<double> ts; + + if (snap_tang) { // Find all points that lead to a tangential snap + if (origins_and_vector.second) { // if "second" is true then "first" is a vector, otherwise it's a point + ts = find_tangents_by_vector(origin_or_vector_doc, curve->toSBasis()); + } else { + ts = find_tangents(origin_or_vector_doc, curve->toSBasis()); + } + for (double t : ts) { + point_dt = dt->doc2dt(curve->pointAt(t)); + dist = Geom::distance(point_dt, p.getPoint()); + isr.points.emplace_back(point_dt, p.getSourceType(), p.getSourceNum(), SNAPTARGET_PATH_TANGENTIAL, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), false, true); + } + } + + if (snap_perp) { // Find all points that lead to a perpendicular snap + if (origins_and_vector.second) { + ts = find_normals_by_vector(origin_or_vector_doc, curve->toSBasis()); + } else { + ts = find_normals(origin_or_vector_doc, curve->toSBasis()); + } + for (double t : ts) { + point_dt = dt->doc2dt(curve->pointAt(t)); + dist = Geom::distance(point_dt, p.getPoint()); + isr.points.emplace_back(point_dt, p.getSourceType(), p.getSourceNum(), SNAPTARGET_PATH_PERPENDICULAR, dist, getSnapperTolerance(), getSnapperAlwaysSnap(), false, true); + } + } + } +} + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : |