Code

Node tool: snap while scaling a selection of nodes. Consider this as experimental...
[inkscape.git] / src / snap.h
index c85c51963a9652efd5fdd0408375080e4330d1c9..8f8416ee5ad0c2216efb32bfedb3739dab372739 100644 (file)
@@ -98,12 +98,17 @@ public:
                               std::vector<Inkscape::SnapCandidatePoint> *unselected_nodes = NULL,
                               SPGuide *guide_to_ignore = NULL);
 
+    void unSetup() {_rotation_center_source_items = NULL;
+                    _guide_to_ignore = NULL;
+                    _desktop = NULL;
+                    _unselected_nodes = NULL;}
+
     // If we're dragging a rotation center, then setRotationCenterSource() stores the parent item
     // of this rotation center; this reference is used to make sure that we do not snap a rotation
     // center to itself
     // NOTE: Must be called after calling setup(), not before!
-    void setRotationCenterSource(SPItem *item) {_rotation_center_source_item = item;}
-    SPItem* getRotationCenterSource() {return _rotation_center_source_item;}
+    void setRotationCenterSource(GSList *items) {_rotation_center_source_items = items;}
+    GSList const *getRotationCenterSource() {return _rotation_center_source_items;}
 
     // freeSnapReturnByRef() is preferred over freeSnap(), because it only returns a
     // point if snapping has occurred (by overwriting p); otherwise p is untouched
@@ -130,49 +135,55 @@ public:
                                            Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
 
     Inkscape::SnappedPoint multipleConstrainedSnaps(Inkscape::SnapCandidatePoint const &p,
-                                                        std::vector<Inkscape::Snapper::SnapConstraint> const &constraints,
-                                                        Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
+                                                    std::vector<Inkscape::Snapper::SnapConstraint> const &constraints,
+                                                    bool dont_snap = false,
+                                                    Geom::OptRect const &bbox_to_snap = Geom::OptRect()) const;
+
+    Inkscape::SnappedPoint constrainedAngularSnap(Inkscape::SnapCandidatePoint const &p,
+                                                    boost::optional<Geom::Point> const &p_ref,
+                                                    Geom::Point const &o,
+                                                    unsigned const snaps) const;
 
     void guideFreeSnap(Geom::Point &p, Geom::Point const &guide_normal, SPGuideDragType drag_type) const;
     void guideConstrainedSnap(Geom::Point &p, SPGuide const &guideline) const;
 
     Inkscape::SnappedPoint freeSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                Geom::Point const &pointer,
-                                               Geom::Point const &tr) const;
+                                               Geom::Point const &tr);
 
     Inkscape::SnappedPoint constrainedSnapTranslate(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                       Geom::Point const &pointer,
                                                       Inkscape::Snapper::SnapConstraint const &constraint,
-                                                      Geom::Point const &tr) const;
+                                                      Geom::Point const &tr);
 
     Inkscape::SnappedPoint freeSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                          Geom::Point const &pointer,
                                          Geom::Scale const &s,
-                                         Geom::Point const &o) const;
+                                         Geom::Point const &o);
 
     Inkscape::SnappedPoint constrainedSnapScale(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                 Geom::Point const &pointer,
                                                 Geom::Scale const &s,
-                                                Geom::Point const &o) const;
+                                                Geom::Point const &o);
 
     Inkscape::SnappedPoint constrainedSnapStretch(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                   Geom::Point const &pointer,
                                                   Geom::Coord const &s,
                                                   Geom::Point const &o,
                                                   Geom::Dim2 d,
-                                                  bool uniform) const;
+                                                  bool uniform);
 
     Inkscape::SnappedPoint constrainedSnapSkew(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                Geom::Point const &pointer,
                                                Inkscape::Snapper::SnapConstraint const &constraint,
                                                Geom::Point const &s, // s[0] = skew factor, s[1] = scale factor
                                                Geom::Point const &o,
-                                               Geom::Dim2 d) const;
+                                               Geom::Dim2 d);
 
     Inkscape::SnappedPoint constrainedSnapRotate(std::vector<Inkscape::SnapCandidatePoint> const &p,
                                                     Geom::Point const &pointer,
                                                     Geom::Coord const &angle,
-                                                    Geom::Point const &o) const;
+                                                    Geom::Point const &o);
 
     Inkscape::GuideSnapper guide;      ///< guide snapper
     Inkscape::ObjectSnapper object;    ///< snapper to other objects
@@ -189,13 +200,14 @@ public:
     bool getSnapIndicator() const {return _snapindicator;}
 
     Inkscape::SnappedPoint findBestSnap(Inkscape::SnapCandidatePoint const &p, SnappedConstraints const &sc, bool constrained, bool noCurves = false, bool allowOffScreen = false) const;
+    void keepClosestPointOnly(std::vector<Inkscape::SnapCandidatePoint> &points, const Geom::Point &reference) const;
 
 protected:
     SPNamedView const *_named_view;
 
 private:
     std::vector<SPItem const *> _items_to_ignore; ///< Items that should not be snapped to, for example the items that are currently being dragged. Set using the setup() method
-    SPItem *_rotation_center_source_item; // to avoid snapping a rotation center to itself
+    GSList *_rotation_center_source_items; // to avoid snapping a rotation center to itself
     SPGuide *_guide_to_ignore; ///< A guide that should not be snapped to, e.g. the guide that is currently being dragged
     SPDesktop const *_desktop;
     bool _snapindicator; ///< When true, an indicator will be drawn at the position that was being snapped to
@@ -209,7 +221,7 @@ private:
                                             Geom::Point const &transformation,
                                             Geom::Point const &origin,
                                             Geom::Dim2 dim,
-                                            bool uniform) const;
+                                            bool uniform);
 
     Geom::Point _transformPoint(Inkscape::SnapCandidatePoint const &p,
                                             Transformation const transformation_type,