Store cached icons to disk between runs, and invalidate/purge as needed.

[inkscape.git] / src / snapper.h

diff --git a/src/snapper.h b/src/snapper.h
index 47c1c514e4ed389db63e55c0dd8b67b265cbf6a0..91784d3aefa539adf5751e1b58795a3b0f7e6dae 100644 (file)
--- a/src/snapper.h
+++ b/src/snapper.h
@@ -15,6 +15,7 @@
 #include <map>
 #include <list>
 #include <boost/optional.hpp>
+#include <glib.h> // for g_assert
 
 #include "snapped-point.h"
 #include "snapped-line.h"
@@ -58,24 +59,36 @@ public:
     bool getSnapVisibleOnly() const {return _snap_visible_only;}
 
     virtual void freeSnap(SnappedConstraints &/*sc*/,
-                          SnapPreferences::PointType const &/*t*/,
                           Inkscape::SnapCandidatePoint const &/*p*/,
                           Geom::OptRect const &/*bbox_to_snap*/,
                           std::vector<SPItem const *> const */*it*/,
                           std::vector<SnapCandidatePoint> */*unselected_nodes*/) const {};
 
-    class ConstraintLine
+    // Class for storing the constraint for constrained snapping; can be
+    // - a line (infinite line with origin, running through _point pointing in _direction)
+    // - a direction (infinite line without origin, i.e. only a direction vector, stored in _direction)
+    // - a circle (_point denotes the center, _radius doesn't need an explanation, _direction contains
+    //      the vector from the origin to the original untransformed point);
+    class SnapConstraint
     {
-    public:
-        ConstraintLine(Geom::Point const &d) : _has_point(false), _direction(d) {}
-        ConstraintLine(Geom::Point const &p, Geom::Point const &d) : _has_point(true), _point(p), _direction(d) {}
-        ConstraintLine(Geom::Line const &l) : _has_point(true), _point(l.origin()), _direction(l.versor()) {}
+    private:
+        enum SnapConstraintType {LINE, DIRECTION, CIRCLE, UNDEFINED};
 
-        bool hasPoint() const {
-            return _has_point;
-        }
+    public:
+        // Constructs a direction constraint, e.g. horizontal or vertical but without a specified point
+        SnapConstraint(Geom::Point const &d) : _direction(d), _type(DIRECTION) {}
+        // Constructs a linear constraint
+        SnapConstraint(Geom::Point const &p, Geom::Point const &d) : _point(p), _direction(d), _type(LINE) {}
+        SnapConstraint(Geom::Line const &l) : _point(l.origin()), _direction(l.versor()), _type(LINE) {}
+        // Constructs a circular constraint
+        SnapConstraint(Geom::Point const &p, Geom::Point const &d, Geom::Coord const &r) : _point(p), _direction(d), _radius(r), _type(CIRCLE) {}
+        // Undefined, or empty constraint
+        SnapConstraint() : _type(UNDEFINED) {}
+
+        bool hasPoint() const {return _type != DIRECTION && _type != UNDEFINED;}
 
         Geom::Point getPoint() const {
+            g_assert(_type != DIRECTION && _type != UNDEFINED);
             return _point;
         }
 
@@ -83,30 +96,51 @@ public:
             return _direction;
         }
 
-        void setPoint(Geom::Point const &p) {
-            _point = p;
-            _has_point = true;
+        Geom::Coord getRadius() const {
+            g_assert(_type == CIRCLE);
+            return _radius;
         }
 
-        Geom::Point projection(Geom::Point const &p) const { // returns the projection of p on this constraintline
-            Geom::Point const p1_on_cl = _has_point ? _point : p;
-            Geom::Point const p2_on_cl = p1_on_cl + _direction;
-            return Geom::projection(p, Geom::Line(p1_on_cl, p2_on_cl));
+        bool isCircular() const { return _type == CIRCLE; }
+        bool isLinear() const { return _type == LINE; }
+        bool isDirection() const { return _type == DIRECTION; }
+        bool isUndefined() const { return _type == UNDEFINED; }
+
+        Geom::Point projection(Geom::Point const &p) const { // returns the projection of p on this constraint
+            if (_type == CIRCLE) {
+                // project on to a circular constraint
+                Geom::Point v_orig = p - _point;
+                Geom::Coord l = Geom::L2(v_orig);
+                if (l > 0) {
+                    return _point + _radius * v_orig/l; // Length of _direction is equal to the radius
+                } else {
+                    // point to be projected is exactly at the center of the circle, so any point on the circle is a projection
+                    return _point + Geom::Point(_radius, 0);
+                }
+            } else if (_type != UNDEFINED){
+                // project on to a linear constraint
+                Geom::Point const p1_on_cl = (_type == LINE) ? _point : p;
+                Geom::Point const p2_on_cl = p1_on_cl + _direction;
+                return Geom::projection(p, Geom::Line(p1_on_cl, p2_on_cl));
+            } else {
+                g_warning("Bug: trying to find the projection onto an undefined constraint");
+                return Geom::Point();
+            }
         }
 
     private:
-
-        bool _has_point;
         Geom::Point _point;
         Geom::Point _direction;
+        Geom::Coord _radius;
+        SnapConstraintType _type;
     };
 
     virtual void constrainedSnap(SnappedConstraints &/*sc*/,
-                                 SnapPreferences::PointType const &/*t*/,
                                  Inkscape::SnapCandidatePoint const &/*p*/,
                                  Geom::OptRect const &/*bbox_to_snap*/,
-                                 ConstraintLine const &/*c*/,
-                                 std::vector<SPItem const *> const */*it*/) const {};
+                                 SnapConstraint const &/*c*/,
+                                 std::vector<SPItem const *> const */*it*/,
+                                 std::vector<SnapCandidatePoint> */*unselected_nodes*/) const {};
 
 protected:
     SnapManager *_snapmanager;