update to trunk lp:inkscape 13530 (fixes Windows build)

(bzr r13341.1.155)

6 files changed, 58 insertions, 62 deletions

diff --git a/src/file.cpp b/src/file.cpp
index 2f13ae3b0..7181f4f98 100644
--- a/src/file.cpp
+++ b/src/file.cpp
@@ -148,14 +148,14 @@ SPDesktop *sp_file_new(const std::string &templ)
         DocumentUndo::setUndoSensitive(doc, true);
     }
     
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    if (desktop)
-        desktop->setWaitingCursor();
+    SPDesktop *olddesktop = SP_ACTIVE_DESKTOP;
+    if (olddesktop)
+        olddesktop->setWaitingCursor();
     
     SPViewWidget *dtw = sp_desktop_widget_new(sp_document_namedview(doc, NULL)); // TODO this will trigger broken link warnings, etc.
     g_return_val_if_fail(dtw != NULL, NULL);
     sp_create_window(dtw, TRUE);
-    desktop = static_cast<SPDesktop *>(dtw->view);
+    SPDesktop* desktop = static_cast<SPDesktop *>(dtw->view);
 
     doc->doUnref();
 
@@ -166,6 +166,8 @@ SPDesktop *sp_file_new(const std::string &templ)
     Inkscape::Extension::Dbus::dbus_init_desktop_interface(desktop);
 #endif
     
+    if (olddesktop)
+        olddesktop->clearWaitingCursor();
     if (desktop)
         desktop->clearWaitingCursor();
 
diff --git a/src/inkscape-x64.rc b/src/inkscape-x64.rc
index 47dbcb2bc..65a2b08b9 100644
--- a/src/inkscape-x64.rc
+++ b/src/inkscape-x64.rc
@@ -3,8 +3,8 @@ APPLICATION_ICON    ICON          DISCARDABLE     "../inkscape.ico"
 1                   24            DISCARDABLE     "./inkscape-manifest-x64.xml"
 
 1 VERSIONINFO
-    FILEVERSION     0,91pre2,0,0
-    PRODUCTVERSION  0,91pre2,0,0
+    FILEVERSION     0,91,0,0
+    PRODUCTVERSION  0,91,0,0
 BEGIN
     BLOCK "StringFileInfo"
     BEGIN
diff --git a/src/inkscape.rc b/src/inkscape.rc
index 2c2c0112b..689653f74 100644
--- a/src/inkscape.rc
+++ b/src/inkscape.rc
@@ -3,8 +3,8 @@ APPLICATION_ICON    ICON          DISCARDABLE     "../inkscape.ico"
 1                   24            DISCARDABLE     "./inkscape-manifest.xml"
 
 1 VERSIONINFO
-    FILEVERSION     0,91pre2,0,0
-    PRODUCTVERSION  0,91pre2,0,0
+    FILEVERSION     0,91,0,0
+    PRODUCTVERSION  0,91,0,0
 BEGIN
     BLOCK "StringFileInfo"
     BEGIN
diff --git a/src/inkview.rc b/src/inkview.rc
index efbe2568b..43a63c725 100644
--- a/src/inkview.rc
+++ b/src/inkview.rc
@@ -3,8 +3,8 @@ APPLICATION_ICON    ICON          DISCARDABLE     "../inkscape.ico"
 1                   24            DISCARDABLE     "./inkview-manifest.xml"
 
 1 VERSIONINFO
-    FILEVERSION     0,91pre2,0,0
-    PRODUCTVERSION  0,91pre2,0,0
+    FILEVERSION     0,91,0,0
+    PRODUCTVERSION  0,91,0,0
 BEGIN
     BLOCK "StringFileInfo"
     BEGIN
diff --git a/src/seltrans.cpp b/src/seltrans.cpp
index 6b8cd19bb..e15249f94 100644
--- a/src/seltrans.cpp
+++ b/src/seltrans.cpp
@@ -9,7 +9,7 @@
  *   Abhishek Sharma
  *
  * Copyright (C) 1999-2002 Lauris Kaplinski
- * Copyright (C) 1999-2008 Authors
+ * Copyright (C) 1999-2014 Authors
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
@@ -1109,10 +1109,17 @@ gboolean Inkscape::SelTrans::skewRequest(SPSelTransHandle const &handle, Geom::P
             break;
     }
 
+    // _point and _origin are noisy, ranging from 1 to 1e-9 or even smaller; this is due to the
+    // limited SVG output precision, which can be arbitrarily set in the preferences
     Geom::Point const initial_delta = _point - _origin;
 
-    if (fabs(initial_delta[dim_a]) < 1e-15) {
-        return false;
+    // The handle and the origin shouldn't be too close to each other; let's check for that!
+    // Due to the limited resolution though (see above), we'd better use a relative error here
+    if (_bbox) {
+        Geom::Coord d = (*_bbox).dimensions()[dim_a];
+        if (fabs(initial_delta[dim_a]/d) < 1e-4) {
+            return false;
+        }
     }
 
     // Calculate the scale factors, which can be either visual or geometric
diff --git a/src/snap.cpp b/src/snap.cpp
index ea6322e37..5b795b22f 100644
--- a/src/snap.cpp
+++ b/src/snap.cpp
@@ -274,7 +274,7 @@ Inkscape::SnappedPoint SnapManager::constrainedSnap(Inkscape::SnapCandidatePoint
 
 /* See the documentation for constrainedSnap() directly above for more details.
  * The difference is that multipleConstrainedSnaps() will take a list of constraints instead of a single one,
- * and will try to snap the SnapCandidatePoint to all of the provided constraints and see which one fits best
+ * and will try to snap the SnapCandidatePoint to only the closest constraint
  *  \param p Source point to be snapped
  *  \param constraints List of directions or lines along which snapping must occur
  *  \param dont_snap If true then we will only apply the constraint, without snapping
@@ -293,16 +293,11 @@ Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandi
         return no_snap;
     }
 
-    IntermSnapResults isr;
-    SnapperList const snappers = getSnappers();
-    std::vector<Geom::Point> projections;
-    bool snapping_is_futile = !someSnapperMightSnap() || dont_snap;
-
-    Inkscape::SnappedPoint result = no_snap;
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool snap_mouse = prefs->getBool("/options/snapmousepointer/value", false);
+    // We haven't tried to snap yet; we will first determine which constraint is closest to where we are now,
+    // i.e. lets find out which of the constraints yields the closest projection of point p
 
+    // Project the mouse pointer on each of the constraints
+    std::vector<Geom::Point> projections;
     for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
         // Project the mouse pointer onto the constraint; In case we don't snap then we will
         // return the projection onto the constraint, such that the constraint is always enforced
@@ -310,55 +305,47 @@ Inkscape::SnappedPoint SnapManager::multipleConstrainedSnaps(Inkscape::SnapCandi
         projections.push_back(pp);
     }
 
-    if (snap_mouse && p.isSingleHandle() && !dont_snap) {
+    // Select the closest constraint
+    no_snap.setPoint(projections.front());
+    Inkscape::Snapper::SnapConstraint cc = constraints.front(); //closest constraint
+
+    std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin();
+    std::vector<Geom::Point>::iterator pp = projections.begin();
+    for (; pp != projections.end(); ++pp) {
+        if (Geom::L2(*pp - p.getPoint()) < Geom::L2(no_snap.getPoint() - p.getPoint())) {
+            no_snap.setPoint(*pp); // Remember the projection onto the closest constraint
+            cc = *c; // Remember the closest constraint itself
+        }
+        ++c;
+    }
+
+    if (!someSnapperMightSnap() || dont_snap) {
+        return no_snap;
+    }
+
+    IntermSnapResults isr;
+    SnapperList const snappers = getSnappers();
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    bool snap_mouse = prefs->getBool("/options/snapmousepointer/value", false);
+
+    Inkscape::SnappedPoint result = no_snap;
+    if (snap_mouse && p.isSingleHandle()) {
         // 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 is basically
         // then just a freesnap with the constraint applied afterwards
         // We'll only to this if we're dragging a single handle, and for example not when transforming an object in the selector tool
         result = freeSnap(p, bbox_to_snap);
+        // Now apply the constraint afterwards
+        result.setPoint(cc.projection(result.getPoint()));
     } else {
-        // Iterate over the constraints
-        for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
-            // Try to snap to the constraint
-            if (!snapping_is_futile) {
-                for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); ++i) {
-                    (*i)->constrainedSnap(isr, p, bbox_to_snap, *c, &_items_to_ignore,_unselected_nodes);
-                }
-            }
+        // Try to snap along the closest constraint
+        for (SnapperList::const_iterator i = snappers.begin(); i != snappers.end(); ++i) {
+            (*i)->constrainedSnap(isr, p, bbox_to_snap, cc, &_items_to_ignore,_unselected_nodes);
         }
         result = findBestSnap(p, isr, true);
     }
 
-    if (result.getSnapped()) {
-        if (snap_mouse) {
-            // If "snap_mouse" then we still have to apply the constraint, because so far we only tried a freeSnap
-            Geom::Point result_closest;
-            for (std::vector<Inkscape::Snapper::SnapConstraint>::const_iterator c = constraints.begin(); c != constraints.end(); ++c) {
-                // Project the mouse pointer onto the constraint; In case we don't snap then we will
-                // return the projection onto the constraint, such that the constraint is always enforced
-                Geom::Point result_p = (*c).projection(result.getPoint());
-                if (c == constraints.begin() || (Geom::L2(result_p - p.getPoint()) < Geom::L2(result_closest - p.getPoint()))) {
-                    result_closest = result_p;
-                }
-            }
-            result.setPoint(result_closest);
-        }
-        return result;
-    }
-
-    // So we didn't snap, but we still need to return a point on one of the constraints
-    // Find out which of the constraints yielded the closest projection of point p
-    for (std::vector<Geom::Point>::iterator pp = projections.begin(); pp != projections.end(); ++pp) {
-        if (pp != projections.begin()) {
-            if (Geom::L2(*pp - p.getPoint()) < Geom::L2(no_snap.getPoint() - p.getPoint())) {
-                no_snap.setPoint(*pp);
-            }
-        } else {
-            no_snap.setPoint(projections.front());
-        }
-    }
-
-    return no_snap;
+    return result.getSnapped() ? result : no_snap;
 }
 
 Inkscape::SnappedPoint SnapManager::constrainedAngularSnap(Inkscape::SnapCandidatePoint const &p,