Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 443 insertions, 0 deletions

diff --git a/src/snapped-point.cpp b/src/snapped-point.cpp
new file mode 100644
index 0000000..8350ccb
--- /dev/null
+++ b/src/snapped-point.cpp
@@ -0,0 +1,443 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ *  \file src/snapped-point.cpp
+ *  SnappedPoint class.
+ *
+ *  Authors:
+ *    Mathieu Dimanche <mdimanche@free.fr>
+ *    Diederik van Lierop <mail@diedenrezi.nl>
+ *
+ *  Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <utility>
+#include "snapped-point.h"
+#include "preferences.h"
+
+// overloaded constructor
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained, Geom::OptRect target_bbox) :
+    _point(p),
+    //_alignment_target(Geom::Point(0,0)),
+    //_alignment_target2(Geom::Point(0,0)),
+    _equal_distance(Geom::infinity()),
+    _tangent(Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),// tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox(std::move(target_bbox)),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, Geom::Point const &ap, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained, Geom::OptRect target_bbox) :
+    _point(p),
+    _alignment_target(ap),
+    //_alignment_target2(Geom::Point(0,0)),
+    _alignment_target_type(target),
+    _equal_distance(Geom::infinity()),
+    _tangent(Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),// tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox(std::move(target_bbox)),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, Geom::Point const &ap, Geom::Point const &ap2, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained, Geom::OptRect target_bbox) :
+    _point(p),
+    _alignment_target(ap),
+    _alignment_target2(ap2),
+    _alignment_target_type(target),
+    _equal_distance(Geom::infinity()),
+    _tangent(Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),// tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox(std::move(target_bbox)),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, std::vector<Geom::Rect> const &bboxes, Geom::Rect const &source_bbox, Geom::Coord equal_dist, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained) :
+    _point(p),
+    _equal_distance(equal_dist),
+    _distribution_bboxes(std::move(bboxes)), 
+    _source_bbox(source_bbox),
+    _tangent(Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),// tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    //_target_bbox(std::move(target_bbox)),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, std::vector<Geom::Rect> const &bboxes, std::vector<Geom::Rect> const &bboxes2, Geom::Rect const &source_bbox, Geom::Coord equal_dist, Geom::Coord equal_dist2, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained) :
+    _point(p),
+    _equal_distance(equal_dist),
+    _equal_distance2(equal_dist2),
+    _distribution_bboxes(std::move(bboxes)), 
+    _distribution_bboxes2(std::move(bboxes2)), 
+    _source_bbox(source_bbox),
+    _tangent(Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),// tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    //_target_bbox(std::move(target_bbox)),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Inkscape::SnapCandidatePoint const &p, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &constrained_snap, bool const &fully_constrained) :
+    _point (p.getPoint()),
+    _equal_distance(Geom::infinity()),
+    _tangent (Geom::Point(0,0)),
+    _source (p.getSourceType()),
+    _source_num (p.getSourceNum()),
+    _target(target),
+    _at_intersection (false),
+    _constrained_snap (constrained_snap),
+    _fully_constrained (fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),
+    _always_snap(a),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox (p.getTargetBBox()),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, long source_num, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &at_intersection, bool const &constrained_snap, bool const &fully_constrained, Geom::Coord const &d2, Geom::Coord const &t2, bool const &a2) :
+    _point(p),
+    _equal_distance(Geom::infinity()),
+    _tangent (Geom::Point(0,0)),
+    _source(source),
+    _source_num(source_num),
+    _target(target),
+    _at_intersection(at_intersection),
+    _constrained_snap(constrained_snap),
+    _fully_constrained(fully_constrained),
+    _distance(d),
+    _tolerance(std::max(t,1.0)),
+    _always_snap(a),
+    _second_distance(d2),
+    _second_tolerance(std::max(t2,1.0)),
+    _second_always_snap(a2),
+    // tolerance should never be smaller than 1 px, as it is used for normalization in
+    // isOtherSnapBetter. We don't want a division by zero.
+    _target_bbox (Geom::OptRect()),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint():
+    _point (Geom::Point(0,0)),
+    _equal_distance(Geom::infinity()),
+    _tangent (Geom::Point(0,0)),
+    _source (SNAPSOURCE_UNDEFINED),
+    _source_num (-1),
+    _target (SNAPTARGET_UNDEFINED),
+    _at_intersection (false),
+    _constrained_snap (false),
+    _fully_constrained (false),
+    _distance (Geom::infinity()),
+    _tolerance (1),
+    _always_snap (false),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox (Geom::OptRect()),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p):
+    _point (p),
+    _equal_distance(Geom::infinity()),
+    _tangent (Geom::Point(0,0)),
+    _source (SNAPSOURCE_UNDEFINED),
+    _source_num (-1),
+    _target (SNAPTARGET_UNDEFINED),
+    _at_intersection (false),
+    _constrained_snap (false),
+    _fully_constrained (false),
+    _distance (Geom::infinity()),
+    _tolerance (1),
+    _always_snap (false),
+    _second_distance (Geom::infinity()),
+    _second_tolerance (1),
+    _second_always_snap (false),
+    _target_bbox (Geom::OptRect()),
+    _pointer_distance (Geom::infinity())
+{
+}
+
+Inkscape::SnappedPoint::~SnappedPoint()
+= default;
+
+void Inkscape::SnappedPoint::getPointIfSnapped(Geom::Point &p) const
+{
+    // When we have snapped
+    if (getSnapped()) {
+        // then return the snapped point by overwriting p
+        p = _point;
+    } //otherwise p will be left untouched; this way the caller doesn't have to check whether we've snapped
+}
+
+// search for the closest snapped point
+// This function give preference to the snapped points that are not in SNAPTARGET_ALIGNMENT_CATEGORY
+// ie. for example, a longer Corner to Corner snap will be given prefrence over 
+// a Corner to alignment snap with lesser snapDistance.
+//
+// Incase there is an alignment snap along with a distribution snap possible, this
+// function returns a new SnappedPoint that is are mix of the both
+bool getClosestSP(std::list<Inkscape::SnappedPoint> const &list, Inkscape::SnappedPoint &result)
+{
+    bool success = false;
+    bool aligned_success = false;
+
+    Inkscape::SnappedPoint aligned;
+
+    for (std::list<Inkscape::SnappedPoint>::const_iterator i = list.begin(); i != list.end(); ++i) {
+        bool alignment = (*i).getTarget() & Inkscape::SNAPTARGET_ALIGNMENT_CATEGORY;
+        if (i == list.begin()) {
+            result = *i;
+            success = !alignment;
+            aligned = *i;
+            aligned_success = alignment;
+        } else if (alignment) {
+            if (!aligned_success || (*i).getSnapDistance() <= aligned.getSnapDistance()) {
+                if ((*i).getSnapDistance() == aligned.getSnapDistance()) {
+                    if ((*i).getDistanceToAlignTarget() < aligned.getDistanceToAlignTarget()) {
+                        aligned = *i;
+                        aligned_success = true; 
+                    }
+                } else {
+                        aligned = *i;
+                        aligned_success = true; 
+                }
+           }
+        } else if (!success || (*i).getSnapDistance() < result.getSnapDistance()){
+            result = *i;
+            success = true;
+        }
+        
+    }
+
+    if (!success && aligned_success)
+        result = aligned;
+
+    // the following code merges an alignment snap and a distribution snap
+    if (success && aligned_success) {
+        bool align_intersection = aligned.getTarget() == Inkscape::SNAPTARGET_ALIGNMENT_INTERSECTION;
+        auto type = result.getTarget();
+
+        if (type & Inkscape::SNAPTARGET_DISTRIBUTION_CATEGORY) {
+            switch (type) {
+                case Inkscape::SNAPTARGET_DISTRIBUTION_X:
+                case Inkscape::SNAPTARGET_DISTRIBUTION_RIGHT:
+                case Inkscape::SNAPTARGET_DISTRIBUTION_LEFT:
+                    if (aligned.getPoint().y() == aligned.getAlignmentTarget()->y()) {
+                        result.setPoint({result.getPoint().x(), aligned.getPoint().y()});
+                        result.setAlignmentTargetType(Inkscape::SNAPTARGET_ALIGNMENT_BBOX_CORNER);
+                        result.setAlignmentTarget(aligned.getAlignmentTarget());
+
+                        if (align_intersection && abs(result.getPoint().x() - aligned.getAlignmentTarget2()->x()) <1e-4) {
+                            result.setPoint(aligned.getPoint());
+                            result.setAlignmentTarget2(aligned.getAlignmentTarget2());
+                            result.setAlignmentTargetType(aligned.getAlignmentTargetType());
+                        }
+                    }
+                    break;
+
+                case Inkscape::SNAPTARGET_DISTRIBUTION_Y:
+                case Inkscape::SNAPTARGET_DISTRIBUTION_UP:
+                case Inkscape::SNAPTARGET_DISTRIBUTION_DOWN:
+                    if (!align_intersection) {
+                        if (aligned.getPoint().x() == aligned.getAlignmentTarget()->x()) {
+                            result.setPoint({aligned.getPoint().x(), result.getPoint().y()});
+                            result.setAlignmentTargetType(aligned.getAlignmentTargetType());
+                            result.setAlignmentTarget(aligned.getAlignmentTarget());
+                        }
+                    } else if (aligned.getPoint().x() == aligned.getAlignmentTarget2()->x()) {
+                            result.setPoint({aligned.getPoint().x(), result.getPoint().y()});
+                            result.setAlignmentTargetType(Inkscape::SNAPTARGET_ALIGNMENT_BBOX_CORNER);
+                            result.setAlignmentTarget(aligned.getAlignmentTarget2());
+
+                            if (abs(result.getPoint().y() - aligned.getAlignmentTarget()->y()) <1e-4) {
+                                result.setPoint(aligned.getPoint());
+                                result.setAlignmentTarget2(aligned.getAlignmentTarget());
+                                result.setAlignmentTargetType(aligned.getAlignmentTargetType());
+                            }
+                    }
+                    break;
+
+                case Inkscape::SNAPTARGET_DISTRIBUTION_XY:
+                    if (Geom::L2(result.getPoint() - aligned.getPoint()) < 1e-4) {
+                        result.setPoint(aligned.getPoint());
+                        result.setAlignmentTargetType(aligned.getAlignmentTargetType());
+                        result.setAlignmentTarget(aligned.getAlignmentTarget());
+                        result.setAlignmentTarget2(aligned.getAlignmentTarget2());
+                    }
+                    break;
+
+                default:
+                    g_warning("getClosestSP(): unknown distribution snap target %i", result.getTarget());
+                    break;
+            }
+
+            return true;
+        }
+    }
+
+    return success ? success : aligned_success;
+}
+
+bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &other_one, bool weighted) const
+{
+
+    if (getSnapped() && !other_one.getSnapped()) {
+        return false;
+    }
+
+    if (!getSnapped() && other_one.getSnapped()) {
+        return true;
+    }
+
+    double dist_other = other_one.getSnapDistance();
+    double dist_this = getSnapDistance();
+
+    // The distance to the pointer should only be taken into account when finding the best snapped source node (when
+    // there's more than one). It is not useful when trying to find the best snapped target point.
+    // (both the snap distance and the pointer distance are measured in document pixels, not in screen pixels)
+    if (weighted) {
+        Geom::Coord const dist_pointer_other = other_one.getPointerDistance();
+        Geom::Coord const dist_pointer_this = getPointerDistance();
+        // Weight factor: controls which node should be preferred for snapping, which is either
+        // the node with the closest snap (w = 0), or the node closest to the mousepointer (w = 1)
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        double w = prefs->getDoubleLimited("/options/snapweight/value", 0.5, 0, 1);
+        if (prefs->getBool("/options/snapclosestonly/value", false)) {
+            w = 1;
+        }
+        if (w > 0) {
+            if (!(w == 1 && dist_pointer_this == dist_pointer_other)) {
+                // When accounting for the distance to the mouse pointer, then at least one of the snapped points should
+                // have that distance set. If not, then this is a bug. Either "weighted" must be set to false, or the
+                // mouse pointer distance must be set.
+                g_assert(dist_pointer_this != Geom::infinity() || dist_pointer_other != Geom::infinity());
+                // The snap distance will always be smaller than the tolerance set for the snapper. The pointer distance can
+                // however be very large. To compare these in a fair way, we will have to normalize these metrics first
+                // The closest pointer distance will be normalized to 1.0; the other one will be > 1.0
+                // The snap distance will be normalized to 1.0 if it's equal to the snapper tolerance
+                double const norm_p = std::min(dist_pointer_this, dist_pointer_other) + 1;
+                // make sure norm_p is never too close to zero (e.g. when snapping the bbox-corner that was grabbed), by incr. with 1
+                double const norm_t_other = std::min(50.0, other_one.getTolerance());
+                double const norm_t_this = std::min(50.0, getTolerance());
+                dist_other = w * dist_pointer_other / norm_p + (1-w) * dist_other / norm_t_other;
+                dist_this = w * dist_pointer_this / norm_p + (1-w) * dist_this / norm_t_this;
+            }
+        }
+    }
+
+    // When snapping to a constraint line only, which is not really a snap but merely a projection
+    // to the constraint line, then give this snap a very low priority. Basically, any other snap will do
+    if (other_one.getTarget() == SNAPTARGET_CONSTRAINT) {
+        dist_other += 1e6;
+    }
+    if (getTarget() == SNAPTARGET_CONSTRAINT) {
+        dist_this += 1e6;
+    }
+
+    // If it's closer
+    bool c1 = dist_other < dist_this;
+    // or, if it's for a snapper with "always snap" turned on, and the previous wasn't
+    bool c2 = other_one.getAlwaysSnap() && !getAlwaysSnap();
+    // But in no case fall back from a snapper with "always snap" on to one with "always snap" off
+    bool c2n = !other_one.getAlwaysSnap() && getAlwaysSnap();
+    // or, if we have a fully constrained snappoint (e.g. to a node or an intersection), while the previous one was only partly constrained (e.g. to a line)
+    bool c3 = (other_one.getFullyConstrained() && !other_one.getConstrainedSnap()) && !getFullyConstrained(); // Do not consider constrained snaps here, because these will always be fully constrained anyway
+    // But in no case fall back; (has less priority than c3n, so it is allowed to fall back when c3 is true, see below)
+    bool c3n = !other_one.getFullyConstrained() && (getFullyConstrained() && !getConstrainedSnap());
+
+    // When both are fully constrained AND coincident, then prefer nodes over intersections
+    bool d = other_one.getFullyConstrained() && getFullyConstrained() && (Geom::L2(other_one.getPoint() - getPoint()) < 1e-9);
+    bool c4 = d && !other_one.getAtIntersection() && getAtIntersection();
+    // But don't fall back...
+    bool c4n = d && other_one.getAtIntersection() && !getAtIntersection();
+
+    // or, if it's just as close then consider the second distance ...
+    bool c5a = (dist_other == dist_this);
+    bool c5b = (other_one.getSecondSnapDistance() < getSecondSnapDistance()) && (getSecondSnapDistance() < Geom::infinity());
+    // ... or prefer free snaps over constrained snaps
+    bool c5c = !other_one.getConstrainedSnap() && getConstrainedSnap();
+
+    bool other_is_better = (c1 || c2 || c3 || c4 || (c5a && (c5b || c5c))) && !c2n && (!c3n || c2) && !c4n;
+
+    /*
+    std::cout << other_one.getPoint() << " (Other one, dist = " << dist_other << ") vs. " << getPoint() << " (this one, dist = " << dist_this << ") ---> ";
+    std::cout << "c1 = " << c1 << " | c2 = " << c2 << " | c2n = " << c2n << " | c3 = " << c3 << " | c3n = " << c3n << " | c4 = " << c4 << " | c4n = " << c4n << " | c5a = " << c5a << " | c5b = " << c5b << " | c5c = " << c5c << std::endl;
+    std::cout << "Other one provides a better snap: " << other_is_better << std::endl;
+    */
+
+    return other_is_better;
+}
+
+/*
+  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 :