X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fknot-holder-entity.cpp;h=36a072c444b92d2767c611b5845dcd3ce1d05057;hb=891cc5c74e3c3c2f83a12cd730721d18dd931398;hp=3c95bb0b4651c5005ed06f2370c22205d0e3203a;hpb=69c9ed09bc39129d04ebc6de145badce52000b76;p=inkscape.git

diff --git a/src/knot-holder-entity.cpp b/src/knot-holder-entity.cpp
index 3c95bb0b4..36a072c44 100644
--- a/src/knot-holder-entity.cpp
+++ b/src/knot-holder-entity.cpp
@@ -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"
@@ -27,6 +27,7 @@
 #include "desktop.h"
 #include "sp-namedview.h"
 #include <2geom/matrix.h>
+#include <2geom/transforms.h>
 
 int KnotHolderEntity::counter = 0;
 
@@ -76,101 +77,104 @@ KnotHolderEntity::~KnotHolderEntity()
 void
 KnotHolderEntity::update_knot()
 {
-    NR::Matrix const i2d(from_2geom(sp_item_i2d_affine(item)));
+    Geom::Matrix const i2d(sp_item_i2d_affine(item));
 
-    NR::Point dp(knot_get() * i2d);
+    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();
 }
 
-NR::Point
-KnotHolderEntity::snap_knot_position(NR::Point const &p)
+Geom::Point
+KnotHolderEntity::snap_knot_position(Geom::Point const &p)
 {
-    NR::Matrix const i2d (from_2geom(sp_item_i2d_affine(item)));
-    NR::Point s = p * i2d;
+    Geom::Matrix const i2d (sp_item_i2d_affine(item));
+    Geom::Point s = p * i2d;
     SnapManager &m = desktop->namedview->snap_manager;
-    m.setup(desktop, item);
-    m.freeSnapReturnByRef(Inkscape::Snapper::SNAPPOINT_NODE, s);
+    m.setup(desktop, true, item);
+    m.freeSnapReturnByRef(Inkscape::SnapPreferences::SNAPPOINT_NODE, s);
     return s * i2d.inverse();
 }
 
 
 /* Pattern manipulation */
 
-static gdouble sp_pattern_extract_theta(SPPattern *pat, NR::Point scale)
+/*  TODO: this pattern manipulation is not able to handle general transformation matrices. Only matrices that are the result of a pure scale times a pure rotation. */
+
+static gdouble sp_pattern_extract_theta(SPPattern *pat)
 {
-    gdouble theta = asin(pat->patternTransform[1] / scale[NR::X]);
-    if (pat->patternTransform[0] < 0) theta = M_PI - theta ;
-    return theta;
+    Geom::Matrix transf = pat->patternTransform;
+    return Geom::atan2(transf.xAxis());
 }
 
-static NR::Point sp_pattern_extract_scale(SPPattern *pat)
+static Geom::Point sp_pattern_extract_scale(SPPattern *pat)
 {
-    Geom::Matrix transf = to_2geom(pat->patternTransform);
-    return NR::Point( transf.expansionX(), transf.expansionY() );
+    Geom::Matrix transf = pat->patternTransform;
+    return Geom::Point( transf.expansionX(), transf.expansionY() );
 }
 
-static NR::Point sp_pattern_extract_trans(SPPattern const *pat)
+static Geom::Point sp_pattern_extract_trans(SPPattern const *pat)
 {
-    return NR::Point(pat->patternTransform[4], pat->patternTransform[5]);
+    return Geom::Point(pat->patternTransform[4], pat->patternTransform[5]);
 }
 
 void
-PatternKnotHolderEntityXY::knot_set(NR::Point const &p, NR::Point const &origin, guint state)
+PatternKnotHolderEntityXY::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
 {
     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 
-    NR::Point p_snapped = snap_knot_position(p);
+    // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
+    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)  {
-        NR::Point const q = p_snapped - sp_pattern_extract_trans(pat);
-        sp_item_adjust_pattern(item, NR::Matrix(NR::translate(q)));
+        Geom::Point const q = p_snapped - sp_pattern_extract_trans(pat);
+        sp_item_adjust_pattern(item, Geom::Matrix(Geom::Translate(q)));
     }
 
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }
 
-NR::Point
+Geom::Point
 PatternKnotHolderEntityXY::knot_get()
 {
     SPPattern const *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
     return sp_pattern_extract_trans(pat);
 }
 
-NR::Point
+Geom::Point
 PatternKnotHolderEntityAngle::knot_get()
 {
     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 
     gdouble x = (pattern_width(pat));
     gdouble y = 0;
-    NR::Point delta = NR::Point(x,y);
-    NR::Point scale = sp_pattern_extract_scale(pat);
-    gdouble theta = sp_pattern_extract_theta(pat, scale);
-    delta = delta * NR::Matrix(NR::scale(scale))*NR::Matrix(NR::rotate(theta));
+    Geom::Point delta = Geom::Point(x,y);
+    Geom::Point scale = sp_pattern_extract_scale(pat);
+    gdouble theta = sp_pattern_extract_theta(pat);
+    delta = delta * Geom::Matrix(Geom::Scale(scale))*Geom::Matrix(Geom::Rotate(theta));
     delta = delta + sp_pattern_extract_trans(pat);
     return delta;
 }
 
 void
-PatternKnotHolderEntityAngle::knot_set(NR::Point const &p, NR::Point const &/*origin*/, guint state)
+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));
 
     // get the angle from pattern 0,0 to the cursor pos
-    NR::Point delta = p - sp_pattern_extract_trans(pat);
+    Geom::Point delta = p - sp_pattern_extract_trans(pat);
     gdouble theta = atan2(delta);
 
     if ( state & GDK_CONTROL_MASK ) {
@@ -178,52 +182,59 @@ PatternKnotHolderEntityAngle::knot_set(NR::Point const &p, NR::Point const &/*or
     }
 
     // get the scale from the current transform so we can keep it.
-    NR::Point scl = sp_pattern_extract_scale(pat);
-    NR::Matrix rot = NR::Matrix(NR::scale(scl)) * NR::Matrix(NR::rotate(theta));
-    NR::Point const t = sp_pattern_extract_trans(pat);
-    rot[4] = t[NR::X];
-    rot[5] = t[NR::Y];
+    Geom::Point scl = sp_pattern_extract_scale(pat);
+    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[Geom::X];
+    rot[5] = t[Geom::Y];
     sp_item_adjust_pattern(item, rot, true);
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }
 
 void
-PatternKnotHolderEntityScale::knot_set(NR::Point const &p, NR::Point const &/*origin*/, guint /*state*/)
+PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
 {
     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 
-    NR::Point p_snapped = snap_knot_position(p);
+    // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
+    Geom::Point p_snapped = snap_knot_position(p);
 
-    // get angle from current transform, (need get current scale first to calculate angle)
-    NR::Point oldscale = sp_pattern_extract_scale(pat);
-    gdouble theta = sp_pattern_extract_theta(pat,oldscale);
+    // get angle from current transform
+    gdouble theta = sp_pattern_extract_theta(pat);
 
     // Get the new scale from the position of the knotholder
-    NR::Point d = p_snapped - sp_pattern_extract_trans(pat);
-    d *= NR::Matrix(NR::rotate(-theta));
+    Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
     gdouble pat_x = pattern_width(pat);
     gdouble pat_y = pattern_height(pat);
-    NR::Point scl (d[NR::X] / pat_x, d[NR::Y] / pat_y);
+    Geom::Scale scl(1);
+    if ( state & GDK_CONTROL_MASK ) {
+        // if ctrl is pressed: use 1:1 scaling
+        gdouble pat_h = hypot(pat_x, pat_y);
+        scl = Geom::Scale(d.length() / pat_h);
+    } else {
+        d *= Geom::Rotate(-theta);
+        scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
+    }
 
-    NR::Matrix rot =  NR::Matrix(NR::scale(scl)) * NR::Matrix(NR::rotate(theta));
+    Geom::Matrix rot = (Geom::Matrix)scl * Geom::Rotate(theta);
 
-    NR::Point const t = sp_pattern_extract_trans(pat);
-    rot[4] = t[NR::X];
-    rot[5] = t[NR::Y];
+    Geom::Point const t = sp_pattern_extract_trans(pat);
+    rot[4] = t[Geom::X];
+    rot[5] = t[Geom::Y];
     sp_item_adjust_pattern(item, rot, true);
     item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 }
 
 
-NR::Point
+Geom::Point
 PatternKnotHolderEntityScale::knot_get()
 {
     SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
 
     gdouble x = pattern_width(pat);
     gdouble y = pattern_height(pat);
-    NR::Point delta = NR::Point(x,y);
-    NR::Matrix a = pat->patternTransform;
+    Geom::Point delta = Geom::Point(x,y);
+    Geom::Matrix a = pat->patternTransform;
     a[4] = 0;
     a[5] = 0;
     delta = delta * a;