Saved for next refactor

(bzr r11950.1.37)

5 files changed, 170 insertions, 141 deletions

diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index 8147ae014..8dc840556 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -32,15 +32,15 @@ LPEBSpline::~LPEBSpline()
 void
 LPEBSpline::doEffect(SPCurve * curve)
 {
-    using Geom::X;
-    using Geom::Y;
-
     if(curve->get_segment_count() < 2)
     return;
     // Make copy of old path as it is changed during processing
     Geom::PathVector const original_pathv = curve->get_pathvector();
     curve->reset();
     //Sbasis
+    Geom::D2< Geom::SBasis > SBasisIn;
+    Geom::D2< Geom::SBasis > SBasisOut;
+    Geom::D2< Geom::SBasis > SBasisEnd;
     Geom::D2< Geom::SBasis > SBasisHelper;
     //curves
     SPCurve * in = new SPCurve();
@@ -63,9 +63,9 @@ LPEBSpline::doEffect(SPCurve * curve)
     Geom::Point nextPointAt1(0,0);
     Geom::Point nextPointAt2(0,0);
     Geom::Point nextPointAt3(0,0);
-    Geom::CubicBezier const *cubicIn;
-    Geom::CubicBezier const *cubicOut;
-    Geom::CubicBezier const *cubicEnd;
+    
+    Geom::Point endPointAt2(0,0);
+    Geom::CubicBezier const *cubic;
     //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el penúltimo
     for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
         //Si está vacío... 
@@ -75,7 +75,7 @@ LPEBSpline::doEffect(SPCurve * curve)
         
         Geom::Path::const_iterator curve_it1 = path_it->begin();      // incoming curve
         Geom::Path::const_iterator curve_it2 = ++(path_it->begin());         // outgoing curve
-        Geom::Path::const_iterator curve_end = path_it->end(); // end curve 
+        Geom::Path::const_iterator curve_end = path_it->end_open(); // end curve 
         Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop
 
         //Creamos las lineas rectas que unen todos los puntos del trazado y donde se calcularán
@@ -92,12 +92,31 @@ LPEBSpline::doEffect(SPCurve * curve)
         //Si la curva está cerrada calculamos el punto donde
         //deveria estar el nodo BSpline de cierre/inicio de la curva
         //en posible caso de que se cierre con una linea recta creando un nodo BSPline
-        cubicEnd = dynamic_cast<Geom::CubicBezier const*>(&*curve_end);
-        cubicIn = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
-        if (path_it->closed() && cubicEnd && cubicIn) {
-            //Calculamos el nodo de inicio BSpline
-            lineHelper->moveto((*cubicIn)[1]);
-            lineHelper->lineto((*cubicEnd)[2]);
+
+        if (path_it->closed()) {
+            // if the path is closed, maybe we have to stop a bit earlier because the closing line segment has zerolength.
+            const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type Geom::LineSegment.
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                // closingline.isDegenerate() did not work, because it only checks for *exact* zero length, which goes wrong for relative coordinates and rounding errors...
+                // the closing line segment has zero-length. So stop before that one!
+                curve_endit = path_it->end_open();
+            }
+            SBasisIn = in->first_segment()->toSBasis();
+            SBasisEnd = end->first_segment()->toSBasis();
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
+            if(cubic){
+                pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1],*in->first_segment()));
+            }else{
+                pointAt1 = in->first_segment()->initialPoint();
+            }
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_end);
+            if(cubic){
+                endPointAt2 = SBasisEnd.valueAt(Geom::nearest_point((*cubic)[2],*end->first_segment()));
+            }else{
+                endPointAt2 = end->first_segment()->finalPoint();
+            }
+            lineHelper->moveto(pointAt1);
+            lineHelper->lineto(endPointAt2);
             SBasisHelper = lineHelper->first_segment()->toSBasis();
             lineHelper->reset();
             //Guardamos el principio de la curva
@@ -110,18 +129,18 @@ LPEBSpline::doEffect(SPCurve * curve)
             //Definimos el punto de inicio original de la curva resultante
             node = startNode;
         }
-
         //Recorremos todos los segmentos menos el último
         while ( curve_it2 != curve_endit )
         {
             //previousPointAt3 = pointAt3;
             //Calculamos los puntos que dividirían en tres segmentos iguales el path recto de entrada y de salida
-            cubicIn = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
-            if(cubicIn){
-                pointAt0 = (*cubicIn)[0];
-                pointAt1 = (*cubicIn)[1];
-                pointAt2 = (*cubicIn)[2];
-                pointAt3 = (*cubicIn)[3];
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
+            if(cubic){
+                SBasisIn = in->first_segment()->toSBasis();
+                pointAt0 = (*cubic)[0];
+                pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1],*in->first_segment()));
+                pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2],*in->first_segment()));
+                pointAt3 = (*cubic)[3];
             }else{
                 pointAt0 = in->first_segment()->initialPoint();
                 pointAt1 = in->first_segment()->initialPoint();
@@ -130,15 +149,16 @@ LPEBSpline::doEffect(SPCurve * curve)
             }
             //Y hacemos lo propio con el path de salida
             //nextPointAt0 = curveOut.valueAt(0);
-            cubicOut = dynamic_cast<Geom::CubicBezier const*>(&*curve_it2);
-            if(cubicOut){
-                nextPointAt1 = (*cubicOut)[1];
-                nextPointAt2 = (*cubicOut)[2];
-                nextPointAt3 = (*cubicOut)[3];
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it2);
+            if(cubic){
+                SBasisOut = out->first_segment()->toSBasis();
+                nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1],*out->first_segment()));
+                nextPointAt2 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[2],*out->first_segment()));;
+                nextPointAt3 = (*cubic)[3];
             }else{
-                nextPointAt1 = in->first_segment()->initialPoint();
-                nextPointAt2 = in->first_segment()->finalPoint();
-                nextPointAt3 = in->first_segment()->finalPoint();
+                nextPointAt1 = out->first_segment()->initialPoint();
+                nextPointAt2 = out->first_segment()->finalPoint();
+                nextPointAt3 = out->first_segment()->finalPoint();
             }
             //La curva BSpline se forma calculando el centro del segmanto de unión
             //de el punto situado en las 2/3 partes de el segmento de entrada
@@ -203,7 +223,6 @@ LPEBSpline::doEffect(SPCurve * curve)
     //Todo: remove?
     //delete SBasisHelper;
 }
-
 }; //namespace LivePathEffect
 }; /* namespace Inkscape */
 
diff --git a/src/pen-context.cpp b/src/pen-context.cpp
index e393a706b..350924adb 100644
--- a/src/pen-context.cpp
+++ b/src/pen-context.cpp
@@ -1788,49 +1788,10 @@ static void bspline(SPPenContext *const pc, bool Shift)
     using Geom::X;
     using Geom::Y;
     Geom::CubicBezier const *cubic;
-    if(!Shift){
-            //NODO CUSP formado por nodo SMOOTH
-            //solo mobemos el manejador del nodo final de cada segmento
-            //Es suficiente para mostrar el nodo como CUSP
-            //Usamos 5 puntos
-        if(!pc->red_curve->is_empty()){
-            pc->npoints = 5;
-            pc->p[0] = pc->red_curve->first_segment()->initialPoint();
-            pc->p[3] = pc->red_curve->first_segment()->finalPoint();
-            if(pc->green_curve->is_empty()){
-                pc->p[1] = pc->p[0] + (1./3)*(pc->p[3] - pc->p[0]);
-                pc->p[1] = Geom::Point(pc->p[1][X]+1,pc->p[1][Y]+1);
-            }else{
-                cubic = dynamic_cast<Geom::CubicBezier const*>(&*pc->green_curve->last_segment());
-                if(!cubic || ((*cubic)[2] == (*cubic)[3]))
-                    pc->p[1] = pc->p[0];
-                else{
-                    SPCurve * WPower = new SPCurve();
-                    Geom::D2< Geom::SBasis > SBasisWPower;
-                    WPower->moveto(pc->green_curve->last_segment()->finalPoint());
-                    WPower->lineto(pc->green_curve->last_segment()->initialPoint());
-                    float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment());
-                    WPower->reset();
-                    WPower->moveto(pc->red_curve->last_segment()->initialPoint());
-                    WPower->lineto(pc->red_curve->last_segment()->finalPoint());
-                    SBasisWPower = WPower->first_segment()->toSBasis();
-                    WPower->reset();
-                    pc->p[1] = SBasisWPower.valueAt(WP);
-                    pc->p[1] = Geom::Point(pc->p[1][X]+1,pc->p[1][Y]+1);
-                }
-            }
-            pc->p[2] = pc->p[3] + (1./3)*(pc->p[0] - pc->p[3]);
-            pc->p[2] = Geom::Point(pc->p[2][X]+1,pc->p[2][Y]+1);
-        }
-        if(pc->green_curve->is_empty() && saShift)
-            pc->p[1] = pc->p[0];
-        if(pc->anchor_statusbar && pc->red_curve->is_empty())
-            saShift = false;
-    }else{
+    if(Shift){
         //Continuamos la curva en modo CUSP
         //Guardamos el valor de inicio en cusp para que no se redibuje como SYMM
         if(pc->anchor_statusbar && pc->red_curve->is_empty()){
-            saShift = true;
             SPCurve *previousCurve = new SPCurve();
             if(pc->sa && !pc->sa->curve->is_empty()){
                 previousCurve = pc->sa->curve->copy();
@@ -1844,10 +1805,15 @@ static void bspline(SPPenContext *const pc, bool Shift)
                     lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
                     previousCurve->backspace();
                     previousCurve->append_continuous(lastSeg, 0.0625);
+                    if (pc->sa->start) {
+                        previousCurve = previousCurve->create_reverse();
+                    }
+                    pc->sa->curve->reset();
                     pc->sa->curve = previousCurve;
                 }
             }
         }
+
         if(pc->anchor_statusbar && !pc->red_curve->is_empty()){
             // Step B - both start and end anchored to same curve
             if ( pc->sa && pc->ea
@@ -1866,7 +1832,10 @@ static void bspline(SPPenContext *const pc, bool Shift)
                     lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
                     same->backspace();
                     same->append_continuous(lastSeg, 0.0625);
-                    same = same->create_reverse();
+                    if (pc->sa->start) {
+                        same = same->create_reverse();
+                    }
+                    pc->sa->curve->reset();
                     pc->sa->curve = same;
                 }
             }
@@ -1882,16 +1851,12 @@ static void bspline(SPPenContext *const pc, bool Shift)
                     green->backspace();
                     green->append_continuous(lastSeg, 0.0625);
                     green = green->create_reverse();
+                    pc->green_curve->reset();
                     pc->green_curve = green;
                 }
             }
         }
 
-        if(!pc->green_curve->is_empty()){
-            //Damos valor original a la variable por si se necesita de nuevo
-            saShift = false;
-        }
-
         if (!pc->red_curve->is_empty()){
             pc->npoints = 5;
             pc->p[0] = pc->red_curve->first_segment()->initialPoint();
@@ -1911,6 +1876,42 @@ static void bspline(SPPenContext *const pc, bool Shift)
             
             }
         }
+    }else{
+        //NODO CUSP formado por nodo SMOOTH
+            //solo mobemos el manejador del nodo final de cada segmento
+            //Es suficiente para mostrar el nodo como CUSP
+            //Usamos 5 puntos
+        if(!pc->red_curve->is_empty()){
+            pc->npoints = 5;
+            pc->p[0] = pc->red_curve->first_segment()->initialPoint();
+            pc->p[3] = pc->red_curve->first_segment()->finalPoint();
+            if(pc->green_curve->is_empty()){
+                if(!pc->sa || (pc->sa && pc->p[0] != pc->p[1])){
+                    pc->p[1] = pc->p[0] + (1./3)*(pc->p[3] - pc->p[0]);
+                    pc->p[1] = Geom::Point(pc->p[1][X]+1,pc->p[1][Y]+1);
+                }
+            }else{
+                cubic = dynamic_cast<Geom::CubicBezier const*>(&*pc->green_curve->last_segment());
+                if(!cubic || ((*cubic)[2] == (*cubic)[3]))
+                    pc->p[1] = pc->p[0];
+                else{
+                    SPCurve * WPower = new SPCurve();
+                    Geom::D2< Geom::SBasis > SBasisWPower;
+                    WPower->moveto(pc->green_curve->last_segment()->finalPoint());
+                    WPower->lineto(pc->green_curve->last_segment()->initialPoint());
+                    float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment());
+                    WPower->reset();
+                    WPower->moveto(pc->red_curve->last_segment()->initialPoint());
+                    WPower->lineto(pc->red_curve->last_segment()->finalPoint());
+                    SBasisWPower = WPower->first_segment()->toSBasis();
+                    WPower->reset();
+                    pc->p[1] = SBasisWPower.valueAt(WP);
+                    pc->p[1] = Geom::Point(pc->p[1][X]+1,pc->p[1][Y]+1);
+                }
+            }
+            pc->p[2] = pc->p[3] + (1./3)*(pc->p[0] - pc->p[3]);
+            pc->p[2] = Geom::Point(pc->p[2][X]+1,pc->p[2][Y]+1);
+        }
     }
     bspline_build(pc);
 }
@@ -1974,17 +1975,17 @@ static void bspline_build(SPPenContext *const pc)
     }
 }
 
-static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
+static void bspline_doEffect(SPCurve * curve)
 {
-    using Geom::X;
-    using Geom::Y;
-
     if(curve->get_segment_count() < 2)
     return;
     // Make copy of old path as it is changed during processing
     Geom::PathVector const original_pathv = curve->get_pathvector();
     curve->reset();
     //Sbasis
+    Geom::D2< Geom::SBasis > SBasisIn;
+    Geom::D2< Geom::SBasis > SBasisOut;
+    Geom::D2< Geom::SBasis > SBasisEnd;
     Geom::D2< Geom::SBasis > SBasisHelper;
     //curves
     SPCurve * in = new SPCurve();
@@ -2007,9 +2008,9 @@ static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
     Geom::Point nextPointAt1(0,0);
     Geom::Point nextPointAt2(0,0);
     Geom::Point nextPointAt3(0,0);
-    Geom::CubicBezier const *cubicIn;
-    Geom::CubicBezier const *cubicOut;
-    Geom::CubicBezier const *cubicEnd;
+    
+    Geom::Point endPointAt2(0,0);
+    Geom::CubicBezier const *cubic;
     //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el penúltimo
     for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
         //Si está vacío... 
@@ -2019,7 +2020,7 @@ static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
         
         Geom::Path::const_iterator curve_it1 = path_it->begin();      // incoming curve
         Geom::Path::const_iterator curve_it2 = ++(path_it->begin());         // outgoing curve
-        Geom::Path::const_iterator curve_end = path_it->end(); // end curve 
+        Geom::Path::const_iterator curve_end = path_it->end_open(); // end curve 
         Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop
 
         //Creamos las lineas rectas que unen todos los puntos del trazado y donde se calcularán
@@ -2036,12 +2037,31 @@ static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
         //Si la curva está cerrada calculamos el punto donde
         //deveria estar el nodo BSpline de cierre/inicio de la curva
         //en posible caso de que se cierre con una linea recta creando un nodo BSPline
-        cubicEnd = dynamic_cast<Geom::CubicBezier const*>(&*curve_end);
-        cubicIn = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
-        if (path_it->closed() && cubicEnd && cubicIn) {
-            //Calculamos el nodo de inicio BSpline
-            lineHelper->moveto((*cubicIn)[1]);
-            lineHelper->lineto((*cubicEnd)[2]);
+
+        if (path_it->closed()) {
+            // if the path is closed, maybe we have to stop a bit earlier because the closing line segment has zerolength.
+            const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type Geom::LineSegment.
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                // closingline.isDegenerate() did not work, because it only checks for *exact* zero length, which goes wrong for relative coordinates and rounding errors...
+                // the closing line segment has zero-length. So stop before that one!
+                curve_endit = path_it->end_open();
+            }
+            SBasisIn = in->first_segment()->toSBasis();
+            SBasisEnd = end->first_segment()->toSBasis();
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
+            if(cubic){
+                pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1],*in->first_segment()));
+            }else{
+                pointAt1 = in->first_segment()->initialPoint();
+            }
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_end);
+            if(cubic){
+                endPointAt2 = SBasisEnd.valueAt(Geom::nearest_point((*cubic)[2],*end->first_segment()));
+            }else{
+                endPointAt2 = end->first_segment()->finalPoint();
+            }
+            lineHelper->moveto(pointAt1);
+            lineHelper->lineto(endPointAt2);
             SBasisHelper = lineHelper->first_segment()->toSBasis();
             lineHelper->reset();
             //Guardamos el principio de la curva
@@ -2054,18 +2074,18 @@ static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
             //Definimos el punto de inicio original de la curva resultante
             node = startNode;
         }
-
         //Recorremos todos los segmentos menos el último
         while ( curve_it2 != curve_endit )
         {
             //previousPointAt3 = pointAt3;
             //Calculamos los puntos que dividirían en tres segmentos iguales el path recto de entrada y de salida
-            cubicIn = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
-            if(cubicIn){
-                pointAt0 = (*cubicIn)[0];
-                pointAt1 = (*cubicIn)[1];
-                pointAt2 = (*cubicIn)[2];
-                pointAt3 = (*cubicIn)[3];
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it1);
+            if(cubic){
+                SBasisIn = in->first_segment()->toSBasis();
+                pointAt0 = (*cubic)[0];
+                pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1],*in->first_segment()));
+                pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2],*in->first_segment()));
+                pointAt3 = (*cubic)[3];
             }else{
                 pointAt0 = in->first_segment()->initialPoint();
                 pointAt1 = in->first_segment()->initialPoint();
@@ -2074,15 +2094,16 @@ static void __attribute__((optimize(0))) bspline_doEffect(SPCurve * curve)
             }
             //Y hacemos lo propio con el path de salida
             //nextPointAt0 = curveOut.valueAt(0);
-            cubicOut = dynamic_cast<Geom::CubicBezier const*>(&*curve_it2);
-            if(cubicOut){
-                nextPointAt1 = (*cubicOut)[1];
-                nextPointAt2 = (*cubicOut)[2];
-                nextPointAt3 = (*cubicOut)[3];
+            cubic = dynamic_cast<Geom::CubicBezier const*>(&*curve_it2);
+            if(cubic){
+                SBasisOut = out->first_segment()->toSBasis();
+                nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1],*out->first_segment()));
+                nextPointAt2 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[2],*out->first_segment()));;
+                nextPointAt3 = (*cubic)[3];
             }else{
-                nextPointAt1 = in->first_segment()->initialPoint();
-                nextPointAt2 = in->first_segment()->finalPoint();
-                nextPointAt3 = in->first_segment()->finalPoint();
+                nextPointAt1 = out->first_segment()->initialPoint();
+                nextPointAt2 = out->first_segment()->finalPoint();
+                nextPointAt3 = out->first_segment()->finalPoint();
             }
             //La curva BSpline se forma calculando el centro del segmanto de unión
             //de el punto situado en las 2/3 partes de el segmento de entrada
diff --git a/src/ui/tool/curve-drag-point.cpp b/src/ui/tool/curve-drag-point.cpp
index b83ce1b3c..40dcb5058 100644
--- a/src/ui/tool/curve-drag-point.cpp
+++ b/src/ui/tool/curve-drag-point.cpp
@@ -53,9 +53,12 @@ bool CurveDragPoint::grabbed(GdkEventMotion */*event*/)
 
         // delta is a vector equal 1/3 of distance from first to second
         Geom::Point delta = (second->position() - first->position()) / 3.0;
-        first->front()->move(first->front()->position() + delta);
-        second->back()->move(second->back()->position() - delta);
-
+        //BSpline
+        if(!_pm.isBSpline()){
+            first->front()->move(first->front()->position() + delta);
+            second->back()->move(second->back()->position() - delta);
+        }
+        //BSpline End
         _pm.update();
     } else {
         _segment_was_degenerate = false;
@@ -87,10 +90,13 @@ void CurveDragPoint::dragged(Geom::Point &new_pos, GdkEventMotion *event)
     Geom::Point delta = new_pos - position();
     Geom::Point offset0 = ((1-weight)/(3*t*(1-t)*(1-t))) * delta;
     Geom::Point offset1 = (weight/(3*t*t*(1-t))) * delta;
-
-    first->front()->move(first->front()->position() + offset0);
-    second->back()->move(second->back()->position() + offset1);
-
+    //BSpline
+    if(!_pm.isBSpline()){
+        first->front()->move(first->front()->position() + offset0);
+        second->back()->move(second->back()->position() + offset1);
+    }else if(weight>=0.8)second->back()->move(new_pos);
+    else if(weight<=0.2)first->front()->move(new_pos);
+    //BSpline End
     _pm.update();
 }
 
diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp
index 1a196c857..c6a2df749 100644
--- a/src/ui/tool/node.cpp
+++ b/src/ui/tool/node.cpp
@@ -142,6 +142,7 @@ void Handle::move(Geom::Point const &new_pos)
     Handle *h2 = NULL;
     if(_pm().isBSpline()){
         isBSpline = true;
+        _parent->_selection.insert(_parent);
         //BSpline End
     }
 
@@ -174,6 +175,7 @@ void Handle::move(Geom::Point const &new_pos)
                 other->setDirection(*node_towards, *_parent);
             }
         }
+        setPosition(new_pos);
         //BSpline
         if(isBSpline){
             h = this;
@@ -183,7 +185,6 @@ void Handle::move(Geom::Point const &new_pos)
             this->other()->setPosition(_pm().BSplineHandleReposition(h2,pos));
         }
         //BSpline End
-        setPosition(new_pos);
         return;
     }
 
@@ -580,8 +581,6 @@ void Node::move(Geom::Point const &new_pos)
     if(_pm().isBSpline()){
         Node *n = this;
         pos = _pm().BSplineHandlePosition(n->front());
-        if(pos == 0)
-            pos = _pm().BSplineHandlePosition(n->back());
     }
     //BSpline End
     setPosition(new_pos);
diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp
index c4158931a..ecb8abcf4 100644
--- a/src/ui/tool/path-manipulator.cpp
+++ b/src/ui/tool/path-manipulator.cpp
@@ -1185,21 +1185,18 @@ bool PathManipulator::isBSpline(){
 double PathManipulator::BSplineHandlePosition(Handle *h){
     double pos = 0;
     Node *n = h->parent();
-    Geom::D2< Geom::SBasis > SBasisInsideNodes;
     SPCurve *lineInsideNodes = new SPCurve();
     Node * nextNode = n->nodeToward(h);
     if(nextNode){
         lineInsideNodes->moveto(n->position());
         lineInsideNodes->lineto(nextNode->position());
-        SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis();
         pos = Geom::nearest_point(h->position(),*lineInsideNodes->first_segment());
     }
     return pos;
 }
 
 Geom::Point PathManipulator::BSplineHandleReposition(Handle *h){
-    double pos = 0;
-    pos = this->BSplineHandlePosition(h);
+    double pos = this->BSplineHandlePosition(h);
     return BSplineHandleReposition(h,pos);
 }
 
@@ -1208,7 +1205,7 @@ Geom::Point PathManipulator::BSplineHandleReposition(Handle *h,double pos){
     Geom::D2< Geom::SBasis > SBasisInsideNodes;
     SPCurve *lineInsideNodes = new SPCurve();
     Node * nextNode = n->nodeToward(h);
-    if(nextNode && pos != 0){
+    if(nextNode){
         lineInsideNodes->moveto(n->position());
         lineInsideNodes->lineto(nextNode->position());
         SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis();
@@ -1233,50 +1230,37 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE)
         }
         NodeList::iterator prev = subpath->begin();
         //BSpline
-        float pos = NULL;
+        double pos =0;
         bool isBSpline = false;
         if(this->isBSpline())
             isBSpline = true;
         if(isBSpline){
             pos = BSplineHandlePosition(prev.ptr()->front());
-            prev.ptr()->front()->setPosition(BSplineHandleReposition(prev.ptr()->front(),pos));
-            if(pos == 0){
-                prev.ptr()->setPosition(BSplineHandleReposition(i.ptr()->front(),pos));
-            }
+            prev->front()->setPosition(BSplineHandleReposition(prev->front(),pos));
         }
         //BSpline End
         builder.moveTo(prev->position());
         for (NodeList::iterator i = ++subpath->begin(); i != subpath->end(); ++i) {
             //BSpline
             if (isBSpline) {
-                pos = BSplineHandlePosition(i.ptr()->front());
-                if(pos == 0)
-                    pos = BSplineHandlePosition(i.ptr()->back());
-                i.ptr()->front()->setPosition(BSplineHandleReposition(i.ptr()->front(),pos));
-                i.ptr()->back()->setPosition(BSplineHandleReposition(i.ptr()->back(),pos));
-                if(pos == 0){
-                    i.ptr()->setPosition(BSplineHandleReposition(i.ptr()->front(),pos));
-                }
+                pos = BSplineHandlePosition(i->back());
+                i->front()->setPosition(BSplineHandleReposition(i->front(),pos));
+                i->back()->setPosition(BSplineHandleReposition(i->back(),pos));
             }
             
             //BSpline End
             build_segment(builder, prev.ptr(), i.ptr());
             prev = i;
         }
+        
         if (subpath->closed()) {
             // Here we link the last and first node if the path is closed.
             // If the last segment is Bezier, we add it.
             //BSpline
             if (isBSpline) {
-                pos = BSplineHandlePosition(prev.ptr()->front());
-                if(pos == 0)
-                    pos = BSplineHandlePosition(subpath->begin().ptr()->back());
-                subpath->begin().ptr()->front()->setPosition(BSplineHandleReposition(subpath->begin().ptr()->front(),pos));
-                prev.ptr()->back()->setPosition(BSplineHandleReposition(prev.ptr()->back(),pos));
-                if(pos == 0){
-                    subpath->begin().ptr()->setPosition(BSplineHandleReposition(subpath->begin().ptr()->front(),pos));
-                    prev.ptr()->setPosition(BSplineHandleReposition(prev.ptr()->back(),pos));
-                }
+                pos = BSplineHandlePosition(prev.next()->back());
+                subpath->begin()->front()->setPosition(BSplineHandleReposition(subpath->begin()->front(),pos));
+                prev.next()->back()->setPosition(BSplineHandleReposition(prev.next()->back(),pos));
             }
             //BSpline End
             if (!prev->front()->isDegenerate() || !subpath->begin()->back()->isDegenerate()) {