summaryrefslogtreecommitdiffstats
path: root/src/object-snapper.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
commitcca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch)
tree146f39ded1c938019e1ed42d30923c2ac9e86789 /src/object-snapper.cpp
parentInitial commit. (diff)
downloadinkscape-upstream.tar.xz
inkscape-upstream.zip
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/object-snapper.cpp867
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 :