Clear pointers in the snapmanager if they're no longer needed.

[inkscape.git] / src / knot-holder-entity.cpp

diff --git a/src/knot-holder-entity.cpp b/src/knot-holder-entity.cpp
index 1fd6bc4b52b87c2d115cf3a7baeddb044bb8bf92..0a449771e9e95b395045392049b37eb58845560a 100644 (file)
--- a/src/knot-holder-entity.cpp
+++ b/src/knot-holder-entity.cpp
@@ -1,8 +1,8 @@
 #define __KNOT_HOLDER_ENTITY_C__
 
-/** \file 
- * KnotHolderEntity definition. 
- * 
+/** \file
+ * KnotHolderEntity definition.
+ *
  * Authors:
  *   Mitsuru Oka <oka326@parkcity.ne.jp>
  *   Maximilian Albert <maximilian.albert@gmail.com>
@@ -19,7 +19,7 @@
 #include "knotholder.h"
 #include "sp-item.h"
 #include "style.h"
-#include "prefs-utils.h"
+#include "preferences.h"
 #include "macros.h"
 #include <libnr/nr-matrix-ops.h>
 #include "sp-pattern.h"
@@ -82,7 +82,7 @@ KnotHolderEntity::update_knot()
     Geom::Point dp(knot_get() * i2d);
 
     _moved_connection.block();
-    sp_knot_set_position(knot, dp, SP_KNOT_STATE_NORMAL); 
+    sp_knot_set_position(knot, dp, SP_KNOT_STATE_NORMAL);
     _moved_connection.unblock();
 }
 
@@ -91,9 +91,43 @@ KnotHolderEntity::snap_knot_position(Geom::Point const &p)
 {
     Geom::Matrix const i2d (sp_item_i2d_affine(item));
     Geom::Point s = p * i2d;
+
     SnapManager &m = desktop->namedview->snap_manager;
     m.setup(desktop, true, item);
-    m.freeSnapReturnByRef(Inkscape::Snapper::SNAPPOINT_NODE, s);
+    m.freeSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE);
+    m.unSetup();
+
+    return s * i2d.inverse();
+}
+
+Geom::Point
+KnotHolderEntity::snap_knot_position_constrained(Geom::Point const &p, Inkscape::Snapper::SnapConstraint const &constraint)
+{
+    Geom::Matrix const i2d (sp_item_i2d_affine(item));
+    Geom::Point s = p * i2d;
+
+    SnapManager &m = desktop->namedview->snap_manager;
+    m.setup(desktop, true, item);
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if ((prefs->getBool("/options/snapmousepointer/value", false))) { // legacy behavior (pre v0.47)
+        // Snapping the mouse pointer instead of the constrained position of the knot allows to snap to
+        // things which don't intersect with the constraint line. This should be handled by the
+        // smart dynamic guides which are yet to be implemented, making this behavior more clean and
+        // transparent. With the current implementation it leads to unexpected results, and it doesn't
+        // allow accurately controlling what is being snapped to.
+
+        // freeSnap() will try snapping point p. This will not take into account the constraint, which
+        // is therefore to be enforced after snap_knot_position_constrained() has finished
+        m.freeSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE);
+    } else {
+        // constrainedSnap() will first project the point p onto the constraint line and then try to snap along that line.
+        // This way the constraint is already enforced, no need to worry about that later on
+        Inkscape::Snapper::SnapConstraint transformed_constraint = Inkscape::Snapper::SnapConstraint(constraint.getPoint() * i2d, (constraint.getPoint() + constraint.getDirection()) * i2d - constraint.getPoint() * i2d);
+        m.constrainedSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE, transformed_constraint);
+    }
+    m.unSetup();
+
     return s * i2d.inverse();
 }
 
@@ -128,16 +162,16 @@ PatternKnotHolderEntityXY::knot_set(Geom::Point const &p, Geom::Point const &ori
     Geom::Point p_snapped = snap_knot_position(p);
 
     if ( state & GDK_CONTROL_MASK ) {
-        if (fabs((p - origin)[NR::X]) > fabs((p - origin)[NR::Y])) {
-            p_snapped[NR::Y] = origin[NR::Y];
+        if (fabs((p - origin)[Geom::X]) > fabs((p - origin)[Geom::Y])) {
+            p_snapped[Geom::Y] = origin[Geom::Y];
         } else {
-            p_snapped[NR::X] = origin[NR::X];
+            p_snapped[Geom::X] = origin[Geom::X];
         }
     }
 
     if (state)  {
         Geom::Point const q = p_snapped - sp_pattern_extract_trans(pat);
-        sp_item_adjust_pattern(item, NR::Matrix(Geom::Translate(q)));
+        sp_item_adjust_pattern(item, Geom::Matrix(Geom::Translate(q)));
     }
 
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
@@ -168,7 +202,8 @@ PatternKnotHolderEntityAngle::knot_get()
 void
 PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
 {
-    int const snaps = prefs_get_int_attribute("options.rotationsnapsperpi", "value", 12);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
 
     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 
@@ -182,10 +217,10 @@ PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &
 
     // get the scale from the current transform so we can keep it.
     Geom::Point scl = sp_pattern_extract_scale(pat);
-    NR::Matrix rot = NR::Matrix(Geom::Scale(scl)) * NR::Matrix(Geom::Rotate(theta));
+    Geom::Matrix rot = Geom::Matrix(Geom::Scale(scl)) * Geom::Matrix(Geom::Rotate(theta));
     Geom::Point const t = sp_pattern_extract_trans(pat);
-    rot[4] = t[NR::X];
-    rot[5] = t[NR::Y];
+    rot[4] = t[Geom::X];
+    rot[5] = t[Geom::Y];
     sp_item_adjust_pattern(item, rot, true);
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }
@@ -212,14 +247,14 @@ PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &
         scl = Geom::Scale(d.length() / pat_h);
     } else {
         d *= Geom::Rotate(-theta);
-        scl = Geom::Scale(d[NR::X] / pat_x, d[NR::Y] / pat_y);
+        scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
     }
 
     Geom::Matrix rot = (Geom::Matrix)scl * Geom::Rotate(theta);
 
     Geom::Point const t = sp_pattern_extract_trans(pat);
-    rot[4] = t[NR::X];
-    rot[5] = t[NR::Y];
+    rot[4] = t[Geom::X];
+    rot[5] = t[Geom::Y];
     sp_item_adjust_pattern(item, rot, true);
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }