From 84504bd815a6ef3c5b7b5958ce46429cbab56a66 Mon Sep 17 00:00:00 2001
From: Diederik van Lierop <mail@diedenrezi.nl>
Date: Sat, 3 Nov 2007 14:48:50 +0000
Subject: Groundwork to snap to intersections, e.g. intersections of gridlines
 with guidelines, and of objects with other objects. The snappers used to
 return only SnappedPoints, but now also SnappedLines and SnappedInfiniteLines
 can be returned. SnappedPaths will be implemented later.

(bzr r4016)
---
 src/line-snapper.cpp | 53 ++++++++++++++++++++++------------------------------
 1 file changed, 22 insertions(+), 31 deletions(-)

(limited to 'src/line-snapper.cpp')

diff --git a/src/line-snapper.cpp b/src/line-snapper.cpp
index cf46671c8..3b91fb015 100644
--- a/src/line-snapper.cpp
+++ b/src/line-snapper.cpp
@@ -2,74 +2,65 @@
 #include "libnr/nr-point-fns.h"
 #include "geom.h"
 #include "line-snapper.h"
+#include "snapped-line.cpp"
 
 Inkscape::LineSnapper::LineSnapper(SPNamedView const *nv, NR::Coord const d) : Snapper(nv, d)
 {
 
 }
 
-Inkscape::SnappedPoint Inkscape::LineSnapper::_doFreeSnap(Inkscape::Snapper::PointType const &t,
+void Inkscape::LineSnapper::_doFreeSnap(SnappedConstraints &sc,
+													Inkscape::Snapper::PointType const &t,
 													NR::Point const &p,
 													bool const &f,
                                              		std::vector<NR::Point> &points_to_snap,
                                                     std::list<SPItem const *> const &it) const
 {
-    /* Snap along x (ie to vertical lines) */
-    Inkscape::SnappedPoint const v = _doConstrainedSnap(t, p, f, points_to_snap, component_vectors[NR::X], it);
-    /* Snap along y (ie to horizontal lines) */
-    Inkscape::SnappedPoint const h = _doConstrainedSnap(t, p, f, points_to_snap, component_vectors[NR::Y], it);
+    /* Snap along x (i.e. to vertical lines) */
+    _doConstrainedSnap(sc, t, p, f, points_to_snap, component_vectors[NR::X], it);
+    /* Snap along y (i.e. to horizontal lines) */
+    _doConstrainedSnap(sc, t, p, f, points_to_snap, component_vectors[NR::Y], it);
 
-    /* If we snapped to both, combine the two results.  This is so that, for example,
-    ** we snap nicely to the intersection of two guidelines.
-    */
-    if (v.getDistance() < NR_HUGE && h.getDistance() < NR_HUGE) {
-        return SnappedPoint(NR::Point(v.getPoint()[NR::X], h.getPoint()[NR::Y]), hypot(v.getDistance(), h.getDistance()));
-    }
-
-    /* If we snapped to a vertical line, return that */
-    if (v.getDistance() < NR_HUGE) {
-        return v;
-    }
-
-    /* Otherwise just return any horizontal snap; if we didn't snap to that either
-    ** we haven't snapped to anything.
-    */
-    return h;
 }
 
-Inkscape::SnappedPoint Inkscape::LineSnapper::_doConstrainedSnap(Inkscape::Snapper::PointType const &t, 
+void Inkscape::LineSnapper::_doConstrainedSnap(SnappedConstraints &sc,
+													Inkscape::Snapper::PointType const &t, 
 													NR::Point const &p,
                                                     bool const &f,
                                              		std::vector<NR::Point> &points_to_snap,
                                      				ConstraintLine const &c,
                                                     std::list<SPItem const *> const &it) const
+
 {
     Inkscape::SnappedPoint s = SnappedPoint(p, NR_HUGE);
 
     /* Get the lines that we will try to snap to */
     const LineList lines = _getSnapLines(p);
-
+    
     for (LineList::const_iterator i = lines.begin(); i != lines.end(); i++) {
 
         /* Normal to the line we're trying to snap along */
         NR::Point const n(NR::rot90(NR::unit_vector(c.getDirection())));
 
-        /* Constant term of the line we're trying to snap along */
-        NR::Coord const q = dot(n, c.hasPoint() ? c.getPoint() : p);
+        NR::Point const point_on_line = c.hasPoint() ? c.getPoint() : p;
+        
+        /* Constant term of the line we're trying to snap along */        
+        NR::Coord const q = dot(n, point_on_line);
 
         /* Try to intersect this line with the target line */
-        NR::Point t = p;
+        NR::Point t = NR::Point(NR_HUGE, NR_HUGE);
         IntersectorKind const k = intersector_line_intersection(n, q, component_vectors[i->first], i->second, t);
-
+		
         if (k == INTERSECTS) {
             const NR::Coord dist = L2(t - p);
-            if (dist < getDistance() && dist < s.getDistance() ) {
-                s = SnappedPoint(t, dist);
+            //Store any line that's within snapping range
+            if (dist < getDistance()) {                
+                _addSnappedLine(sc, t, dist, c.getDirection(), t);
+                //SnappedInfiniteLine dummy = SnappedInfiniteLine(t, dist, c.getDirection(), t);
+                //sc.infinite_lines.push_back(dummy);
             }
         }
     }
-
-    return s;
 }
 
 /*
-- 
cgit v1.2.3