update to trunk

(bzr r13708.1.39)

8 files changed, 124 insertions, 106 deletions

diff --git a/src/ui/tool/control-point-selection.cpp b/src/ui/tool/control-point-selection.cpp
index 998f74ee0..f36ad7374 100644
--- a/src/ui/tool/control-point-selection.cpp
+++ b/src/ui/tool/control-point-selection.cpp
@@ -19,6 +19,8 @@
 #include "ui/tool/transform-handle-set.h"
 #include "ui/tool/node.h"
 
+
+
 #include <gdk/gdkkeysyms.h>
 
 namespace Inkscape {
@@ -82,6 +84,7 @@ std::pair<ControlPointSelection::iterator, bool> ControlPointSelection::insert(c
     }
 
     found = _points.insert(x).first;
+    _points_list.push_back(x);
 
     x->updateState();
     _pointChanged(x, true);
@@ -97,6 +100,7 @@ std::pair<ControlPointSelection::iterator, bool> ControlPointSelection::insert(c
 void ControlPointSelection::erase(iterator pos)
 {
     SelectableControlPoint *erased = *pos;
+    _points_list.remove(*pos);
     _points.erase(pos);
     erased->updateState();
     _pointChanged(erased, false);
@@ -219,8 +223,11 @@ void ControlPointSelection::transform(Geom::Affine const &m)
 /** Align control points on the specified axis. */
 void ControlPointSelection::align(Geom::Dim2 axis)
 {
+    enum AlignTargetNode { LAST_NODE=0, FIRST_NODE, MID_NODE, MIN_NODE, MAX_NODE };
     if (empty()) return;
     Geom::Dim2 d = static_cast<Geom::Dim2>((axis + 1) % 2);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
 
     Geom::OptInterval bound;
     for (iterator i = _points.begin(); i != _points.end(); ++i) {
@@ -229,7 +236,27 @@ void ControlPointSelection::align(Geom::Dim2 axis)
 
     if (!bound) { return; }
 
-    double new_coord = bound->middle();
+    double new_coord;
+    switch (AlignTargetNode(prefs->getInt("/dialogs/align/align-nodes-to", 2))){
+        case FIRST_NODE:
+            new_coord=(_points_list.front())->position()[d];
+            break;
+        case LAST_NODE:
+            new_coord=(_points_list.back())->position()[d];
+            break;
+        case MID_NODE:
+            new_coord=bound->middle();
+            break;
+        case MIN_NODE:
+            new_coord=bound->min();
+            break;
+        case MAX_NODE:
+            new_coord=bound->max();
+            break;
+        default:
+            return;
+    }
+
     for (iterator i = _points.begin(); i != _points.end(); ++i) {
         Geom::Point pos = (*i)->position();
         pos[d] = new_coord;
diff --git a/src/ui/tool/control-point-selection.h b/src/ui/tool/control-point-selection.h
index 2d812c0a3..f122a468d 100644
--- a/src/ui/tool/control-point-selection.h
+++ b/src/ui/tool/control-point-selection.h
@@ -12,6 +12,7 @@
 #ifndef SEEN_UI_TOOL_CONTROL_POINT_SELECTION_H
 #define SEEN_UI_TOOL_CONTROL_POINT_SELECTION_H
 
+#include <list>
 #include <memory>
 #include <boost/optional.hpp>
 #include <stddef.h>
@@ -140,6 +141,8 @@ private:
     double _rotationRadius(Geom::Point const &);
 
     set_type _points;
+    //the purpose of this list is to keep track of first and last selected
+    std::list<SelectableControlPoint *> _points_list;
     set_type _all_points;
     INK_UNORDERED_MAP<SelectableControlPoint *, Geom::Point> _original_positions;
     INK_UNORDERED_MAP<SelectableControlPoint *, Geom::Affine> _last_trans;
diff --git a/src/ui/tool/multi-path-manipulator.cpp b/src/ui/tool/multi-path-manipulator.cpp
index 46c6246a1..9ec6f733f 100644
--- a/src/ui/tool/multi-path-manipulator.cpp
+++ b/src/ui/tool/multi-path-manipulator.cpp
@@ -683,13 +683,14 @@ bool MultiPathManipulator::event(Inkscape::UI::Tools::ToolBase *event_context, G
                 //if the trace is bspline ( mode 2)
                 if(mode==2){
                     //  is this correct ?
-                    if(del_preserves_shape ^ held_control(event->key))
+                    if(del_preserves_shape ^ held_control(event->key)){
                         deleteNodes(false);
-                    else
+                    } else {
                         deleteNodes(true);
-                }
-                else
+                    }
+                } else {
                     deleteNodes(del_preserves_shape ^ held_control(event->key));
+                }
 
                 // Delete any selected gradient nodes as well
                 event_context->deleteSelectedDrag(held_control(event->key));
diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp
index ca6f5abb1..d70147f80 100644
--- a/src/ui/tool/node.cpp
+++ b/src/ui/tool/node.cpp
@@ -60,10 +60,8 @@ Inkscape::ControlType nodeTypeToCtrlType(Inkscape::UI::NodeType type)
 namespace Inkscape {
 namespace UI {
 
-/*const double handleCubicGap = 0.01;*/
-const double noPower = 0.0;
-const double defaultStartPower = 0.3334;
-/*const double defaultEndPower = 0.6667;*/
+const double NO_POWER = 0.0;
+const double DEFAULT_START_POWER = 1.0/3.0;
 
 ControlPoint::ColorSet Node::node_colors = {
     {0xbfbfbf00, 0x000000ff}, // normal fill, stroke
@@ -142,6 +140,7 @@ void Handle::move(Geom::Point const &new_pos)
     Node *node_away = _parent->nodeAwayFrom(this); // node in the opposite direction
     Handle *towards = node_towards ? node_towards->handleAwayFrom(_parent) : NULL;
     Handle *towards_second = node_towards ? node_towards->handleToward(_parent) : NULL;
+    double bspline_weight = 0.0;
 
     if (Geom::are_near(new_pos, _parent->position())) {
         // The handle becomes degenerate.
@@ -176,8 +175,9 @@ void Handle::move(Geom::Point const &new_pos)
 
         //move the handler and its oposite the same proportion
         if(_pm()._isBSpline()){
-            setPosition(_pm()._bsplineHandleReposition(this,this));
-            this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
+            setPosition(_pm()._bsplineHandleReposition(this, false));
+            bspline_weight = _pm()._bsplineHandlePosition(this, false);
+            this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(), bspline_weight));
         }
         return;
     }
@@ -193,8 +193,9 @@ void Handle::move(Geom::Point const &new_pos)
 
         //move the handler and its oposite the same proportion
         if(_pm()._isBSpline()){ 
-            setPosition(_pm()._bsplineHandleReposition(this,this));
-            this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
+            setPosition(_pm()._bsplineHandleReposition(this, false));
+            bspline_weight = _pm()._bsplineHandlePosition(this, false);
+            this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(), bspline_weight));
         }
         
         return;
@@ -219,8 +220,9 @@ void Handle::move(Geom::Point const &new_pos)
 
     // moves the handler and its oposite the same proportion
     if(_pm()._isBSpline()){
-        setPosition(_pm()._bsplineHandleReposition(this,this));
-        this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this));
+        setPosition(_pm()._bsplineHandleReposition(this, false));
+        bspline_weight = _pm()._bsplineHandlePosition(this, false);
+        this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(), bspline_weight));
     }
 }
 
@@ -299,7 +301,7 @@ bool Handle::_eventHandler(Inkscape::UI::Tools::ToolBase *event_context, GdkEven
         default: break;
         }
         break;
-    // new double click event to set the handlers of a node to the default proportion, defaultStartPower% 
+    // new double click event to set the handlers of a node to the default proportion, DEFAULT_START_POWER% 
     case GDK_2BUTTON_PRESS:
         handle_2button_press();
         break;
@@ -310,11 +312,11 @@ bool Handle::_eventHandler(Inkscape::UI::Tools::ToolBase *event_context, GdkEven
     return ControlPoint::_eventHandler(event_context, event);
 }
 
-//this function moves the handler and its oposite to the default proportion of defaultStartPower
+//this function moves the handler and its oposite to the default proportion of DEFAULT_START_POWER
 void Handle::handle_2button_press(){
     if(_pm()._isBSpline()){
-        setPosition(_pm()._bsplineHandleReposition(this,defaultStartPower));
-        this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),defaultStartPower));
+        setPosition(_pm()._bsplineHandleReposition(this, DEFAULT_START_POWER));
+        this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(), DEFAULT_START_POWER));
         _pm().update();
     }
 }
@@ -375,7 +377,7 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event)
         if(_pm()._isBSpline()){
             setPosition(new_pos);
             int steps = _pm()._bsplineGetSteps();
-            new_pos=_pm()._bsplineHandleReposition(this,ceilf(_pm()._bsplineHandlePosition(this,this)*steps)/steps);
+            new_pos=_pm()._bsplineHandleReposition(this,ceilf(_pm()._bsplineHandlePosition(this, false)*steps)/steps);
         }
     }
 
@@ -549,7 +551,7 @@ Glib::ustring Handle::_getTip(unsigned state) const
                 "<b>Auto node handle</b>: drag to convert to smooth node (%s)"), more);
         }else{
             return format_tip(C_("Path handle tip",
-                "<b>BSpline node handle</b>: Shift to drag, double click to reset (%s). %g power"),more,_pm()._bsplineHandlePosition(h,NULL));
+                "<b>BSpline node handle</b>: Shift to drag, double click to reset (%s). %g power"),more,_pm()._bsplineHandlePosition(h));
         }
     }
 }
@@ -627,22 +629,18 @@ void Node::move(Geom::Point const &new_pos)
     Geom::Point delta = new_pos - position();
 
     // save the previous nodes strength to apply it again once the node is moved 
-    double nodeWeight = noPower;
-    double nextNodeWeight = noPower;
-    double prevNodeWeight = noPower;
+    double nodeWeight = NO_POWER;
+    double nextNodeWeight = NO_POWER;
+    double prevNodeWeight = NO_POWER;
     Node *n = this;
     Node * nextNode = n->nodeToward(n->front());
     Node * prevNode = n->nodeToward(n->back());
-    nodeWeight = fmax(_pm()._bsplineHandlePosition(n->front()),_pm()._bsplineHandlePosition(n->back()));
+    nodeWeight = fmax(_pm()._bsplineHandlePosition(n->front(), false),_pm()._bsplineHandlePosition(n->back(), false));
     if(prevNode){
-        if(prevNode->isEndNode()){
-            prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front());
-        }
+        prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front());
     }
     if(nextNode){
-        if(nextNode->isEndNode()){
-            nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back());
-        }
+        nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back());
     }
 
     setPosition(new_pos);
@@ -659,18 +657,10 @@ void Node::move(Geom::Point const &new_pos)
         _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight));
         _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight));
         if(prevNode){
-            if(prevNode->isEndNode()){
-                prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight));
-            }else{
-                prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back()));
-            }
+            prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(), prevNodeWeight));
         }
         if(nextNode){
-            if(nextNode->isEndNode()){
-                nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight));
-            }else{
-                nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front()));
-            }
+            nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(), nextNodeWeight));
         }
     }
 }
@@ -681,22 +671,18 @@ void Node::transform(Geom::Affine const &m)
     Geom::Point old_pos = position();
 
     // save the previous nodes strength to apply it again once the node is moved 
-    double nodeWeight = noPower;
-    double nextNodeWeight = noPower;
-    double prevNodeWeight = noPower;
+    double nodeWeight = NO_POWER;
+    double nextNodeWeight = NO_POWER;
+    double prevNodeWeight = NO_POWER;
     Node *n = this;
     Node * nextNode = n->nodeToward(n->front());
     Node * prevNode = n->nodeToward(n->back());
     nodeWeight = _pm()._bsplineHandlePosition(n->front());
     if(prevNode){
-        if(prevNode->isEndNode()){
-            prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front());
-        }
+        prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front());
     }
     if(nextNode){
-        if(nextNode->isEndNode()){
-            nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back());
-        }
+        nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back());
     }
 
     setPosition(position() * m);
@@ -709,21 +695,13 @@ void Node::transform(Geom::Affine const &m)
 
     // move the involved handlers, first the node ones, later the adjoining ones 
     if(_pm()._isBSpline()){
-        _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight));
-        _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight));
+        _front.setPosition(_pm()._bsplineHandleReposition(this->front(), nodeWeight));
+        _back.setPosition(_pm()._bsplineHandleReposition(this->back(), nodeWeight));
         if(prevNode){
-            if(prevNode->isEndNode()){
-                prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight));
-            }else{
-                prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back()));
-            }
+            prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(), prevNodeWeight));
         }
         if(nextNode){
-            if(nextNode->isEndNode()){
-                nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight));
-            }else{
-                nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front()));
-            }
+            nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(), nextNodeWeight));
         }
     }
 }
@@ -913,15 +891,15 @@ void Node::setType(NodeType type, bool update_handles)
             break;
         default: break;
         }
-        /* in node type changes, about bspline traces, we can mantain them with noPower power in border mode,
+        /* in node type changes, about bspline traces, we can mantain them with NO_POWER power in border mode,
            or we give them the default power in curve mode */
         if(_pm()._isBSpline()){
-            double weight = noPower;
-            if(_pm()._bsplineHandlePosition(this->front()) != noPower ){
-                weight = defaultStartPower;
+            double weight = NO_POWER;
+            if(_pm()._bsplineHandlePosition(this->front()) != NO_POWER ){
+                weight = DEFAULT_START_POWER;
             }
-            _front.setPosition(_pm()._bsplineHandleReposition(this->front(),weight));
-            _back.setPosition(_pm()._bsplineHandleReposition(this->back(),weight));
+            _front.setPosition(_pm()._bsplineHandleReposition(this->front(), weight));
+            _back.setPosition(_pm()._bsplineHandleReposition(this->back(), weight));
         }
     }
     _type = type;
@@ -1435,7 +1413,6 @@ Glib::ustring Node::_getTip(unsigned state) const
 {
     bool isBSpline = _pm()._isBSpline();
     Handle *h = const_cast<Handle *>(&_front);
-    Handle *h2 = const_cast<Handle *>(&_back);
     if (state_held_shift(state)) {
         bool can_drag_out = (_next() && _front.isDegenerate()) || (_prev() && _back.isDegenerate());
         if (can_drag_out) {
@@ -1464,7 +1441,7 @@ Glib::ustring Node::_getTip(unsigned state) const
 
     // No modifiers: assemble tip from node type
     char const *nodetype = node_type_to_localized_string(_type);
-    double power = _pm()._bsplineHandlePosition(h,h2);
+    double power = _pm()._bsplineHandlePosition(h);
     if (_selection.transformHandlesEnabled() && selected()) {
         if (_selection.size() == 1 && !isBSpline) {
             return format_tip(C_("Path node tip",
diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp
index 848b10373..f4790c317 100644
--- a/src/ui/tool/path-manipulator.cpp
+++ b/src/ui/tool/path-manipulator.cpp
@@ -56,9 +56,9 @@ enum PathChange {
 };
 
 } // anonymous namespace
-const double HANDLE_CUBIC_GAP = 0.01;
+const double HANDLE_CUBIC_GAP = 0.001;
 const double NO_POWER = 0.0;
-const double defaultStartPower = 0.3334;
+const double DEFAULT_START_POWER = 1.0/3.0;
 
 
 /**
@@ -695,10 +695,12 @@ unsigned PathManipulator::_deleteStretch(NodeList::iterator start, NodeList::ite
     // if we are removing, we readjust the handlers
     if(_isBSpline()){
         if(start.prev()){
-            start.prev()->front()->setPosition(_bsplineHandleReposition(start.prev()->front(),start.prev()->back()));
+            double bspline_weight = _bsplineHandlePosition(start.prev()->back(), false);
+            start.prev()->front()->setPosition(_bsplineHandleReposition(start.prev()->front(), bspline_weight));
         }
         if(end){
-            end->back()->setPosition(_bsplineHandleReposition(end->back(),end->front()));
+            double bspline_weight = _bsplineHandlePosition(end->front(), false);
+            end->back()->setPosition(_bsplineHandleReposition(end->back(),bspline_weight));
         }
     }
 
@@ -1033,7 +1035,7 @@ NodeList::iterator PathManipulator::subdivideSegment(NodeList::iterator first, d
                 line_inside_nodes->moveto(n->position());
                 line_inside_nodes->lineto(second->position());
                 sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis();
-                Geom::Point next = sbasis_inside_nodes.valueAt(defaultStartPower);
+                Geom::Point next = sbasis_inside_nodes.valueAt(DEFAULT_START_POWER);
                 next = Geom::Point(next[Geom::X] + HANDLE_CUBIC_GAP,next[Geom::Y] + HANDLE_CUBIC_GAP);
                 line_inside_nodes->reset();
                 n->front()->setPosition(next);
@@ -1044,7 +1046,7 @@ NodeList::iterator PathManipulator::subdivideSegment(NodeList::iterator first, d
                 line_inside_nodes->moveto(n->position());
                 line_inside_nodes->lineto(first->position());
                 sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis();
-                Geom::Point previous = sbasis_inside_nodes.valueAt(defaultStartPower);
+                Geom::Point previous = sbasis_inside_nodes.valueAt(DEFAULT_START_POWER);
                 previous = Geom::Point(previous[Geom::X] + HANDLE_CUBIC_GAP,previous[Geom::Y] + HANDLE_CUBIC_GAP);
                 n->back()->setPosition(previous);
             }else{
@@ -1277,13 +1279,10 @@ bool PathManipulator::_isBSpline() const {
 }
 
 // returns the corresponding strength to the position of the handlers
-double PathManipulator::_bsplineHandlePosition(Handle *h, Handle *h2)
+double PathManipulator::_bsplineHandlePosition(Handle *h, bool check_other)
 {
     using Geom::X;
     using Geom::Y;
-    if(h2){
-        h = h2;
-    }
     double pos = NO_POWER;
     Node *n = h->parent();
     Node * next_node = NULL;
@@ -1293,19 +1292,19 @@ double PathManipulator::_bsplineHandlePosition(Handle *h, Handle *h2)
         line_inside_nodes->moveto(n->position());
         line_inside_nodes->lineto(next_node->position());
         if(!are_near(h->position(), n->position())){
-            pos = Geom::nearest_time(Geom::Point(h->position()[X] - HANDLE_CUBIC_GAP, h->position()[Y] - HANDLE_CUBIC_GAP), *line_inside_nodes->first_segment());
+            pos = Geom::nearest_time(Geom::Point(h->position()[X] - HANDLE_CUBIC_GAP, h->position()[Y] + HANDLE_CUBIC_GAP), *line_inside_nodes->first_segment());
         }
     }
-    if (pos == NO_POWER && !h2){
-        return _bsplineHandlePosition(h, h->other());
+    if (pos == NO_POWER && check_other){
+        return _bsplineHandlePosition(h->other(), false);
     }
     return pos;
 }
 
 // give the location for the handler in the corresponding position
-Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h, Handle *h2)
+Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h, bool check_other)
 {
-    double pos = this->_bsplineHandlePosition(h, h2);
+    double pos = this->_bsplineHandlePosition(h, check_other);
     return _bsplineHandleReposition(h,pos);
 }
 
diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h
index 4c6f74ba4..283cb610a 100644
--- a/src/ui/tool/path-manipulator.h
+++ b/src/ui/tool/path-manipulator.h
@@ -111,8 +111,8 @@ private:
 
     void _recalculateIsBSpline();
     bool _isBSpline() const;
-    double _bsplineHandlePosition(Handle *h, Handle *h2 = NULL);
-    Geom::Point _bsplineHandleReposition(Handle *h, Handle *h2 = NULL);
+    double _bsplineHandlePosition(Handle *h, bool check_other = true);
+    Geom::Point _bsplineHandleReposition(Handle *h, bool check_other = true);
     Geom::Point _bsplineHandleReposition(Handle *h, double pos);
     void _createGeometryFromControlPoints(bool alert_LPE = false);
     unsigned _deleteStretch(NodeList::iterator first, NodeList::iterator last, bool keep_shape);
diff --git a/src/ui/tool/selector.cpp b/src/ui/tool/selector.cpp
index 051cb41ae..9acf7de88 100644
--- a/src/ui/tool/selector.cpp
+++ b/src/ui/tool/selector.cpp
@@ -39,6 +39,7 @@ public:
         setVisible(false);
         _rubber = static_cast<CtrlRect*>(sp_canvas_item_new(_desktop->getControls(),
         SP_TYPE_CTRLRECT, NULL));
+        _rubber->setShadow(1, 0xffffffff);
         sp_canvas_item_hide(_rubber);
     }
 
diff --git a/src/ui/tool/transform-handle-set.cpp b/src/ui/tool/transform-handle-set.cpp
index da2a54989..748b9d4cc 100644
--- a/src/ui/tool/transform-handle-set.cpp
+++ b/src/ui/tool/transform-handle-set.cpp
@@ -15,9 +15,11 @@
 #include <glib/gi18n.h>
 #include <2geom/transforms.h>
 #include "desktop.h"
+#include "sp-namedview.h"
 
 #include "display/sodipodi-ctrlrect.h"
 #include "preferences.h"
+#include "pure-transform.h"
 #include "snap.h"
 #include "snap-candidate.h"
 #include "sp-namedview.h"
@@ -93,6 +95,7 @@ TransformHandle::TransformHandle(TransformHandleSet &th, SPAnchorType anchor, Gl
     setVisible(false);
 }
 
+// TODO: This code is duplicated in seltrans.cpp; fix this!
 void TransformHandle::getNextClosestPoint(bool reverse)
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -113,6 +116,11 @@ void TransformHandle::getNextClosestPoint(bool reverse)
             _snap_points.clear();
             _snap_points.push_back(*_all_snap_sources_iter);
 
+            // Show the updated snap source now; otherwise it won't be shown until the selection is being moved again
+            SnapManager &m = _desktop->namedview->snap_manager;
+            m.setup(_desktop);
+            m.displaySnapsource(*_all_snap_sources_iter);
+            m.unSetup();
         }
     }
 }
@@ -247,7 +255,7 @@ protected:
         if (Geom::are_near(vold[Geom::X], 0) || Geom::are_near(vold[Geom::Y], 0))
             return Geom::identity();
 
-        double scale[2] = { vnew[Geom::X] / vold[Geom::X], vnew[Geom::Y] / vold[Geom::Y] };
+        Geom::Scale scale = Geom::Scale(vnew[Geom::X] / vold[Geom::X], vnew[Geom::Y] / vold[Geom::Y]);
 
         if (held_alt(*event)) {
             for (unsigned i = 0; i < 2; ++i) {
@@ -261,20 +269,21 @@ protected:
             SnapManager &m = _th._desktop->namedview->snap_manager;
             m.setupIgnoreSelection(_th._desktop, true, &_unselected_points);
 
-            Inkscape::SnappedPoint sp;
+            Inkscape::PureScale *ptr;
             if (held_control(*event)) {
                 scale[0] = scale[1] = std::min(scale[0], scale[1]);
-                sp = m.constrainedSnapScale(_snap_points, _origin, Geom::Scale(scale[0], scale[1]), scc);
+                ptr = new Inkscape::PureScaleConstrained(Geom::Scale(scale[0], scale[1]), scc);
             } else {
-                sp = m.freeSnapScale(_snap_points, _origin, Geom::Scale(scale[0], scale[1]), scc);
+                ptr = new Inkscape::PureScale(Geom::Scale(scale[0], scale[1]), scc, false);
             }
+            m.snapTransformed(_snap_points, _origin, (*ptr));
             m.unSetup();
 
-            if (sp.getSnapped()) {
-                Geom::Point result = sp.getTransformation();
-                scale[0] = result[0];
-                scale[1] = result[1];
+            if (ptr->best_snapped_point.getSnapped()) {
+                scale = ptr->getScaleSnapped();
             }
+
+            delete ptr;
         }
 
         _last_scale_x = scale[0];
@@ -349,11 +358,12 @@ protected:
             m.setupIgnoreSelection(_th._desktop, true, &_unselected_points);
 
             bool uniform = held_control(*event);
-            Inkscape::SnappedPoint sp = m.constrainedSnapStretch(_snap_points, _origin, vs[d1], scc, d1, uniform);
+            Inkscape::PureStretchConstrained psc = Inkscape::PureStretchConstrained(vs[d1], scc, d1, uniform);
+            m.snapTransformed(_snap_points, _origin, psc);
             m.unSetup();
 
-            if (sp.getSnapped()) {
-                Geom::Point result = sp.getTransformation();
+            if (psc.best_snapped_point.getSnapped()) {
+                Geom::Point result = psc.getStretchSnapped().vector(); //best_snapped_point.getTransformation();
                 vs[d1] = result[d1];
                 vs[d2] = result[d2];
             } else {
@@ -414,11 +424,12 @@ protected:
         } else {
             SnapManager &m = _th._desktop->namedview->snap_manager;
             m.setupIgnoreSelection(_th._desktop, true, &_unselected_points);
-            Inkscape::SnappedPoint sp = m.constrainedSnapRotate(_snap_points, _origin, angle, rotc);
+            Inkscape::PureRotateConstrained prc = Inkscape::PureRotateConstrained(angle, rotc);
+            m.snapTransformed(_snap_points, _origin, prc);
             m.unSetup();
 
-            if (sp.getSnapped()) {
-                angle = sp.getTransformation()[0];
+            if (prc.best_snapped_point.getSnapped()) {
+                angle = prc.getAngleSnapped(); //best_snapped_point.getTransformation()[0];
             }
         }
 
@@ -528,13 +539,12 @@ protected:
             SnapManager &m = _th._desktop->namedview->snap_manager;
             m.setupIgnoreSelection(_th._desktop, true, &_unselected_points);
 
-            Geom::Point cvec; cvec[d2] = 1.0;
-            Inkscape::Snapper::SnapConstraint const constraint(cvec);
-            Inkscape::SnappedPoint sp = m.constrainedSnapSkew(_snap_points, _origin, constraint, Geom::Point(skew[d1], scale[d1]), scc, d2);
+            Inkscape::PureSkewConstrained psc = Inkscape::PureSkewConstrained(skew[d1], scale[d1], scc, d2);
+            m.snapTransformed(_snap_points, _origin, psc);
             m.unSetup();
 
-            if (sp.getSnapped()) {
-                skew[d1] =  sp.getTransformation()[0];
+            if (psc.best_snapped_point.getSnapped()) {
+                skew[d1] = psc.getSkewSnapped(); //best_snapped_point.getTransformation()[0];
             }
         }