X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fsnapped-point.cpp;h=48efa10e6fd3dacb1c51ee0ac7b6f311c0cf751a;hb=8cd8b6ee0c2bd47add62310866479d49a2070057;hp=d7f13d82fa298ae6fa0d91b75a34bb7edbc4229d;hpb=771d00baf3d15209a77dce026f7ef45a78365e62;p=inkscape.git

diff --git a/src/snapped-point.cpp b/src/snapped-point.cpp
index d7f13d82f..48efa10e6 100644
--- a/src/snapped-point.cpp
+++ b/src/snapped-point.cpp
@@ -14,11 +14,12 @@
 #include "preferences.h"
 
 // overloaded constructor
-Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &fully_constrained)
-    : _point(p), _source(source), _target(target), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a)
+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), _source(source), _source_num(source_num), _target(target), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a), _target_bbox(target_bbox)
 {
     // tolerance should never be smaller than 1 px, as it is used for normalization in isOtherSnapBetter. We don't want a division by zero.
     _at_intersection = false;
+    _constrained_snap = constrained_snap;
     _fully_constrained = fully_constrained;
     _second_distance = NR_HUGE;
     _second_tolerance = 1;
@@ -27,20 +28,60 @@ Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const
     _pointer_distance = NR_HUGE;
 }
 
-Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p, SnapSourceType const &source, SnapTargetType const &target, Geom::Coord const &d, Geom::Coord const &t, bool const &a, bool const &at_intersection, bool const &fully_constrained, Geom::Coord const &d2, Geom::Coord const &t2, bool const &a2)
-    : _point(p), _source(source), _target(target), _at_intersection(at_intersection), _fully_constrained(fully_constrained), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a),
+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)
+    : _target(target), _distance(d), _tolerance(std::max(t,1.0)), _always_snap(a)
+{
+    _point = p.getPoint();
+    _source = p.getSourceType();
+    _source_num = p.getSourceNum();
+    _at_intersection = false;
+    _constrained_snap = constrained_snap;
+    _fully_constrained = fully_constrained;
+    _second_distance = NR_HUGE;
+    _second_tolerance = 1;
+    _second_always_snap = false;
+    _transformation = Geom::Point(1,1);
+    _pointer_distance = NR_HUGE;
+    _target_bbox = p.getTargetBBox();
+
+}
+
+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), _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.
     _transformation = Geom::Point(1,1);
     _pointer_distance = NR_HUGE;
+    _target_bbox = Geom::OptRect();
 }
 
 Inkscape::SnappedPoint::SnappedPoint()
 {
     _point = Geom::Point(0,0);
     _source = SNAPSOURCE_UNDEFINED,
+    _source_num = 0,
+    _target = SNAPTARGET_UNDEFINED,
+    _at_intersection = false;
+    _constrained_snap = false;
+    _fully_constrained = false;
+    _distance = NR_HUGE;
+    _tolerance = 1;
+    _always_snap = false;
+    _second_distance = NR_HUGE;
+    _second_tolerance = 1;
+    _second_always_snap = false;
+    _transformation = Geom::Point(1,1);
+    _pointer_distance = NR_HUGE;
+    _target_bbox = Geom::OptRect();
+}
+
+Inkscape::SnappedPoint::SnappedPoint(Geom::Point const &p)
+{
+    _point = p;
+    _source = SNAPSOURCE_UNDEFINED,
+    _source_num = 0,
     _target = SNAPTARGET_UNDEFINED,
     _at_intersection = false;
     _fully_constrained = false;
@@ -52,6 +93,7 @@ Inkscape::SnappedPoint::SnappedPoint()
     _second_always_snap = false;
     _transformation = Geom::Point(1,1);
     _pointer_distance = NR_HUGE;
+    _target_bbox = Geom::OptRect();
 }
 
 Inkscape::SnappedPoint::~SnappedPoint()
@@ -64,11 +106,11 @@ void Inkscape::SnappedPoint::getPoint(Geom::Point &p) const
     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 wether we've snapped
+    } //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
-bool getClosestSP(std::list<Inkscape::SnappedPoint> &list, Inkscape::SnappedPoint &result)
+bool getClosestSP(std::list<Inkscape::SnappedPoint> const &list, Inkscape::SnappedPoint &result)
 {
     bool success = false;
 
@@ -85,6 +127,10 @@ bool getClosestSP(std::list<Inkscape::SnappedPoint> &list, Inkscape::SnappedPoin
 bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &other_one, bool weighted) const
 {
 
+    if (!other_one.getSnapped()) {
+        return false;
+    }
+
     double dist_other = other_one.getSnapDistance();
     double dist_this = getSnapDistance();
 
@@ -92,6 +138,8 @@ bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &oth
     // 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();
@@ -100,22 +148,34 @@ bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &oth
             w = 1;
         }
         if (w > 0) {
-            // 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(getPointerDistance() != NR_HUGE || other_one.getPointerDistance() != NR_HUGE);
-            // 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(getPointerDistance(), other_one.getPointerDistance());
-            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 * other_one.getPointerDistance() / norm_p + (1-w) * dist_other / norm_t_other;
-            dist_this = w * getPointerDistance() / norm_p + (1-w) * dist_this / norm_t_this;
+            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 != NR_HUGE || dist_pointer_other != NR_HUGE);
+                // 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
@@ -123,16 +183,31 @@ bool Inkscape::SnappedPoint::isOtherSnapBetter(Inkscape::SnappedPoint const &oth
     // 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() && !getFullyConstrained();
+    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();
-    // or, if it's just as close then consider the second distance
-    bool c4a = (dist_other == dist_this);
-    bool c4b = other_one.getSecondSnapDistance() < getSecondSnapDistance();
-
-    // std::cout << other_one.getPoint() << " (Other one) vs. " << getPoint() << " (this one) ---> ";
-    // std::cout << "c1 = " << c1 << " | c2 = " << c2 << " | c2n = " << c2n << " | c3 = " << c3 << " | c3n = " << c3n << " | c4a = " << c4a << " | c4b = " << c4b << std::endl;
-    return (c1 || c2 || c3 || (c4a && c4b)) && !c2n && (!c3n || c2);
+    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() < NR_HUGE);
+    // ... 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;
 }
 
 /*