merge from trunk (r14473)

(bzr r14425.1.3)

9 files changed, 232 insertions, 139 deletions

diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index 731b5d645..7e92e767d 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -206,6 +206,18 @@ void sp_bspline_do_effect(SPCurve *curve, double helper_size)
         Geom::D2<Geom::SBasis> sbasis_helper;
         Geom::CubicBezier const *cubic = NULL;
         curve_n->moveto(curve_it1->initialPoint());
+        if (path_it->closed()) {
+          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();
+          }
+        }
         while (curve_it1 != curve_endit) {
             SPCurve *in = new SPCurve();
             in->moveto(curve_it1->initialPoint());
@@ -361,6 +373,18 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount)
         Geom::D2<Geom::SBasis> sbasis_out;
         Geom::CubicBezier const *cubic = NULL;
         curve_n->moveto(curve_it1->initialPoint());
+        if (path_it->closed()) {
+          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();
+          }
+        }
         while (curve_it1 != curve_endit) {
             SPCurve *in = new SPCurve();
             in->moveto(curve_it1->initialPoint());
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index 3e0810cfc..574ec3580 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -37,7 +37,7 @@ void LPEFillBetweenMany::doEffect (SPCurve * curve)
 {
     Geom::PathVector res_pathv;
     SPItem * firstObj = NULL;
-    for (std::vector<PathAndDirection*>::iterator iter = linked_paths._vector.begin(); iter != linked_paths._vector.end(); iter++) {
+    for (std::vector<PathAndDirection*>::iterator iter = linked_paths._vector.begin(); iter != linked_paths._vector.end(); ++iter) {
         SPObject *obj;
         if ((*iter)->ref.isAttached() && (obj = (*iter)->ref.getObject()) && SP_IS_ITEM(obj) && !(*iter)->_pathvector.empty()) {
             Geom::Path linked_path;
diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index cea91509e..310f791a1 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -20,6 +20,7 @@
 #include "live_effects/parameter/parameter.h"
 #include <boost/functional/hash.hpp>
 #include "helper/geom.h"
+#include "sp-item-group.h"
 #include <glibmm/i18n.h>
 #include <cmath>
 
@@ -59,13 +60,11 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
                       "global_randomize", &wr, this, 1.),
       handles(_("Handles"), _("Handles options"), "handles", HMConverter, &wr,
              this, HM_ALONG_NODES),
-      max_smooth_angle(_("Max. smooth handle angle"), _("Max. smooth handle angle"),
-                     "max_smooth_angle", &wr, this, 20),
       shift_nodes(_("Shift nodes"), _("Shift nodes"), "shift_nodes", &wr, this,
                  true),
-      fixed_displacement(_("Fixed displacement"), _("Fixed displacement, 1/3 of segment lenght"),
+      fixed_displacement(_("Fixed displacement"), _("Fixed displacement, 1/3 of segment length"),
                        "fixed_displacement", &wr, this, false),
-      spray_tool_friendly(_("Spray Tool friendly"), _("For use with spray tool"),
+      spray_tool_friendly(_("Spray Tool friendly"), _("For use with spray tool in copy mode"),
                        "spray_tool_friendly", &wr, this, false)
 {
     registerParameter(&method);
@@ -75,7 +74,6 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
     registerParameter(&displace_y);
     registerParameter(&global_randomize);
     registerParameter(&handles);
-    registerParameter(&max_smooth_angle);
     registerParameter(&shift_nodes);
     registerParameter(&fixed_displacement);
     registerParameter(&spray_tool_friendly);
@@ -88,17 +86,52 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
     segments.param_set_range(1, Geom::infinity());
     segments.param_set_increments(1, 1);
     segments.param_set_digits(0);
-    max_smooth_angle.param_set_range(0, 359);
-    max_smooth_angle.param_set_increments(1, 1);
-    max_smooth_angle.param_set_digits(0);
     seed = 0;
 }
 
 LPERoughen::~LPERoughen() {}
 
+static void
+sp_get_better_default_size(SPItem *item, double &value)
+{
+    if (SP_IS_GROUP(item)) {
+        std::vector<SPItem*> const item_list = sp_item_group_item_list(SP_GROUP(item));
+        for ( std::vector<SPItem*>::const_iterator iter=item_list.begin();iter!=item_list.end();iter++) {
+            SPItem *subitem = *iter;
+            sp_get_better_default_size(subitem, value);
+        }
+        if(item_list.size() > 0){
+            value /= item_list.size();
+        }
+    } else {
+        SPShape *shape = dynamic_cast<SPShape *>(item);
+        if (shape) {
+            SPCurve * c = NULL;
+            SPPath *path = dynamic_cast<SPPath *>(shape);
+            if (path) {
+                c = path->get_original_curve();
+            } else {
+                c = shape->getCurve();
+            }
+            if (c) {
+                value += Geom::length(paths_to_pw(c->get_pathvector()))/(c->get_segment_count () * 6);
+            }
+        }
+    }
+}
+
+void LPERoughen::doOnApply(SPLPEItem const* lpeitem)
+{
+    SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
+    double initial = 0;
+    sp_get_better_default_size(SP_ITEM(splpeitem), initial);
+    displace_x.param_set_value(initial, 0);
+    displace_y.param_set_value(initial, 0);
+}
+
 void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem)
 {
-    if(spray_tool_friendly && seed == 0){
+    if(spray_tool_friendly && seed == 0 && SP_OBJECT(lpeitem)->getId()){
         std::string id_item(SP_OBJECT(lpeitem)->getId());
         long seed = static_cast<long>(boost::hash_value(id_item));
         global_randomize.param_set_value(global_randomize.get_value(), seed);
@@ -183,19 +216,15 @@ double LPERoughen::sign(double random_number)
     return random_number;
 }
 
-Geom::Point LPERoughen::randomize(double max_lenght, double direction)
+Geom::Point LPERoughen::randomize(double max_lenght, bool is_node)
 {
-    double displace_x_parsed = displace_x * global_randomize;
-    double displace_y_parsed = displace_y * global_randomize;
-    Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed));
-    if( direction != 0){
-        int angle = (int)max_smooth_angle;
-        if (angle == 0){
-            angle = 1;
-        }
-        double dist = Geom::distance(Geom::Point(0,0),output);
-        output  = Geom::Point::polar(direction + sign(Geom::deg_to_rad(rand() % angle)), dist);
+    double factor = 1.0/3.0;
+    if(is_node){
+        factor = 1.0;
     }
+    double displace_x_parsed = displace_x * global_randomize * factor;
+    double displace_y_parsed = displace_y * global_randomize * factor;
+    Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed));
     if( fixed_displacement ){
         Geom::Ray ray(Geom::Point(0,0),output);
         output  = Geom::Point::polar(ray.angle(), max_lenght);
@@ -219,14 +248,27 @@ void LPERoughen::doEffect(SPCurve *curve)
         Geom::Point prev(0, 0);
         Geom::Point last_move(0, 0);
         nCurve->moveto(curve_it1->initialPoint());
+        if (path_it->closed()) {
+          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();
+          }
+        }
         while (curve_it1 != curve_endit) {
             Geom::CubicBezier const *cubic = NULL;
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
             if (cubic) {
-                nCurve->curveto((*cubic)[1], (*cubic)[2], curve_it1->finalPoint());
+                nCurve->curveto((*cubic)[1] + last_move, (*cubic)[2], curve_it1->finalPoint());
             } else {
                 nCurve->lineto(curve_it1->finalPoint());
             }
+            last_move = Geom::Point(0, 0);
             double length = curve_it1->length(0.001);
             std::size_t splits = 0;
             if (method == DM_SEGMENTS) {
@@ -317,9 +359,9 @@ SPCurve const * LPERoughen::addNodesAndJitter(Geom::Curve const * A, Geom::Point
     Geom::Point point_b2(0, 0);
     Geom::Point point_b3(0, 0);
     if (shift_nodes) {
-        point_a3 = randomize(max_lenght);
+        point_a3 = randomize(max_lenght, true);
         if(last){
-            point_b3 = randomize(max_lenght);
+            point_b3 = randomize(max_lenght, true);
         }
     }
     if (handles == HM_RAND || handles == HM_SMOOTH) {
@@ -336,7 +378,82 @@ SPCurve const * LPERoughen::addNodesAndJitter(Geom::Curve const * A, Geom::Point
             point_b2 = point_b3;
         }
     }
-    if(handles == HM_RETRACT){
+    if(handles == HM_SMOOTH){
+        if(cubic) {
+            std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
+            std::vector<Geom::Point> seg1 = div.first.controlPoints(),
+                                     seg2 = div.second.controlPoints();
+            Geom::Ray ray(seg1[3] + point_a3, seg2[1] + point_a3);
+            double lenght = max_lenght;
+            if(!fixed_displacement ){
+                lenght = Geom::distance(seg1[3] + point_a3, seg2[1] + point_a3);
+            }
+            point_b1  = seg1[3] + point_a3 + Geom::Point::polar(ray.angle() , lenght);
+            point_b2  = seg2[2];
+            point_b3  = seg2[3] + point_b3;
+            point_a3 = seg1[3] + point_a3;
+            ray.setPoints(prev,A->initialPoint());
+            point_a1  = A->initialPoint() + Geom::Point::polar(ray.angle(), max_lenght);
+            if(prev == Geom::Point(0,0)){
+                point_a1 = randomize(max_lenght);
+            }
+            if(last){
+                Geom::Path b2(point_b3);
+                b2.appendNew<Geom::LineSegment>(point_a3);
+                lenght = max_lenght;
+                ray.setPoints(point_b3, point_b2);
+                if(!fixed_displacement ){
+                    lenght = Geom::distance(b2.pointAt(1.0/3.0), point_b3);
+                }
+                point_b2  = point_b3 + Geom::Point::polar(ray.angle() , lenght);
+            }
+            ray.setPoints(point_b1, point_a3);
+            point_a2  = point_a3 + Geom::Point::polar(ray.angle(), max_lenght);
+            if(last){
+                prev = point_b2;
+            } else {
+                prev = point_a2;
+            }
+            out->moveto(seg1[0]);
+            out->curveto(point_a1,point_a2,point_a3);
+            out->curveto(point_b1, point_b2, point_b3);
+        } else {
+            Geom::Ray ray(A->pointAt(t) + point_a3,  A->pointAt(t + (t / 3)));
+            double lenght = max_lenght;
+            if(!fixed_displacement ){
+                lenght = Geom::distance(A->pointAt(t) + point_a3,  A->pointAt(t + (t / 3)));
+            }
+            point_b1  = A->pointAt(t) + point_a3 + Geom::Point::polar(ray.angle() , lenght);
+            point_b2  = A->pointAt(t +((t / 3) * 2));
+            point_b3  = A->finalPoint() + point_b3;
+            point_a3 = A->pointAt(t) + point_a3;
+            ray.setPoints(prev,A->initialPoint());
+            point_a1  = A->initialPoint() + Geom::Point::polar(ray.angle(), max_lenght);
+            if(prev == Geom::Point(0,0)){
+                point_a1 = randomize(max_lenght);
+            }
+            if(last){
+                Geom::Path b2(point_b3);
+                b2.appendNew<Geom::LineSegment>(point_a3);
+                lenght = max_lenght;
+                ray.setPoints(point_b3, point_b2);
+                if(!fixed_displacement ){
+                    lenght = Geom::distance(b2.pointAt(1.0/3.0), point_b3);
+                }
+                point_b2  = point_b3 + Geom::Point::polar(ray.angle() , lenght);
+            }
+            ray.setPoints(point_b1, point_a3);
+            point_a2  = point_a3 + Geom::Point::polar(ray.angle(), max_lenght);
+            if(last){
+                prev = point_b2;
+            } else {
+                prev = point_a2;
+            }
+            out->moveto(A->initialPoint());
+            out->curveto(point_a1,point_a2,point_a3);
+            out->curveto(point_b1, point_b2, point_b3);
+        }
+    } else if(handles == HM_RETRACT){
         out->moveto(A->initialPoint());
         out->lineto(A->pointAt(t) + point_a3);
         if(cubic && !last){
@@ -346,63 +463,12 @@ SPCurve const * LPERoughen::addNodesAndJitter(Geom::Curve const * A, Geom::Point
         } else {
             out->lineto(A->finalPoint() + point_b3);
         }
-    } else if(handles == HM_SMOOTH && cubic) {
-        std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
-        std::vector<Geom::Point> seg1 = div.first.controlPoints(),
-                                 seg2 = div.second.controlPoints();
-        Geom::Ray ray(prev,A->initialPoint());
-        point_a1  = Geom::Point::polar(ray.angle(), max_lenght);
-        if(prev == Geom::Point(0,0)){
-            point_a1 = randomize(max_lenght);
-        }
-        ray.setPoints(seg1[3] + point_a3, seg2[1] + point_a3);
-        point_b1  = randomize(max_lenght, ray.angle());
-        if(last){
-            ray.setPoints(seg2[3] + point_b3, A->pointAt(1 - (t / 3)) + point_b3);
-            point_b2  = randomize(max_lenght, ray.angle());
-        }
-        ray.setPoints(seg2[1] + point_a3 + point_b1, seg2[0] + point_a3);
-        point_a2  = Geom::Point::polar(ray.angle(), max_lenght);
-        if(last){
-            prev = A->pointAt(1 - (t / 3)) + point_b2 + point_b3;
-        } else {
-            prev = seg1[3] + point_a2 + point_a3;
-        }
-        out->moveto(seg1[0]);
-        out->curveto(seg1[0] + point_a1, seg1[3] + point_a2 + point_a3, seg1[3] + point_a3);
-        if(last){
-            out->curveto(seg2[1] + point_a3 + point_b1, A->pointAt(1 - (t / 3)) + point_b2 + point_b3, seg2[3] + point_b3);
-        } else {
-            out->curveto(seg2[1] + point_a3 + point_b1, seg2[2] + point_b2 + point_b3, seg2[3] + point_b3);
-        }
-    } else if(handles == HM_SMOOTH && !cubic) {
-        Geom::Ray ray(prev,A->initialPoint());
-        point_a1 = Geom::Point::polar(ray.angle(), max_lenght);
-        if(prev==Geom::Point(0,0)){
-            point_a1 = randomize(max_lenght);
-        }
-        ray.setPoints(A->pointAt(t) + point_a3, A->pointAt(t + (t / 3)) + point_a3);
-        point_b1  = randomize(max_lenght, ray.angle());
-        if(last){
-            ray.setPoints(A->finalPoint() + point_b3, A->pointAt(t +((t / 3) * 2)) + point_b3);
-            point_b2  = randomize(max_lenght, ray.angle());
-        }
-        ray.setPoints(A->pointAt(t + (t / 3)) + point_a3 + point_b1, A->pointAt(t) + point_a3);
-        point_a2  = Geom::Point::polar(ray.angle(), max_lenght);
-        if(last){
-            prev = A->pointAt(t +((t / 3) * 2)) + point_b2 + point_b3;
-        } else {
-            prev =  A->pointAt(t) + point_a3 + point_a2;
-        }
-        out->moveto(A->initialPoint());
-        out->curveto(A->initialPoint() + point_a1, A->pointAt(t) + point_a3 + point_a2, A->pointAt(t) + point_a3);
-        out->curveto(A->pointAt(t + (t / 3)) + point_a3 + point_b1, A->pointAt(t +((t / 3) * 2)) + point_b2 + point_b3, A->finalPoint() + point_b3);
-    } else if (cubic) {
-        std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
-        std::vector<Geom::Point> seg1 = div.first.controlPoints(),
-                                 seg2 = div.second.controlPoints();
-        out->moveto(seg1[0]);
-        if(handles == HM_ALONG_NODES){
+    } else if(handles == HM_ALONG_NODES){
+        if (cubic) {
+            std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
+            std::vector<Geom::Point> seg1 = div.first.controlPoints(),
+                                     seg2 = div.second.controlPoints();
+            out->moveto(seg1[0]);
             out->curveto(seg1[1] + last_move, seg1[2] + point_a3, seg1[3] + point_a3);
             last_move = point_a3;
             if(last){
@@ -410,17 +476,23 @@ SPCurve const * LPERoughen::addNodesAndJitter(Geom::Curve const * A, Geom::Point
             }
             out->curveto(seg2[1] + point_a3, seg2[2]  + point_b3, seg2[3] + point_b3);
         } else {
+            out->moveto(A->initialPoint());
+            out->lineto(A->pointAt(t) + point_a3);
+            out->lineto(A->finalPoint() + point_b3);
+        }
+    } else if(handles == HM_RAND) {
+        if (cubic) {
+            std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
+            std::vector<Geom::Point> seg1 = div.first.controlPoints(),
+                                     seg2 = div.second.controlPoints();
+            out->moveto(seg1[0]);
             out->curveto(seg1[1] + point_a1, seg1[2] + point_a2 + point_a3, seg1[3] + point_a3);
             out->curveto(seg2[1] + point_a3 + point_b1, seg2[2]  + point_b2 + point_b3, seg2[3] + point_b3);
+        } else {
+            out->moveto(A->initialPoint());
+            out->lineto(A->pointAt(t) + point_a3);
+            out->lineto(A->finalPoint() + point_b3);
         }
-    } else if (handles == HM_RAND) {
-        out->moveto(A->initialPoint());
-        out->curveto(A->pointAt(t / 3) + point_a1, A->pointAt((t / 3) * 2) + point_a2  + point_a3, A->pointAt(t) + point_a3);
-        out->curveto(A->pointAt(t + (t / 3)) + point_a3 + point_b1, A->pointAt(t +((t / 3) * 2)) + point_b2 + point_b3, A->finalPoint() + point_b3);
-    } else {
-        out->moveto(A->initialPoint());
-        out->lineto(A->pointAt(t) + point_a3);
-        out->lineto(A->finalPoint() + point_b3);
     }
     return out;
 }
@@ -434,52 +506,52 @@ SPCurve *LPERoughen::jitter(Geom::Curve const * A, Geom::Point &prev, Geom::Poin
     Geom::Point point_a2(0, 0);
     Geom::Point point_a3(0, 0);
     if (shift_nodes) {
-        point_a3 = randomize(max_lenght);
+        point_a3 = randomize(max_lenght, true);
     }
     if (handles == HM_RAND || handles == HM_SMOOTH) {
         point_a1 = randomize(max_lenght);
         point_a2 = randomize(max_lenght);
     }
-    if(handles == HM_RETRACT){
-        out->moveto(A->initialPoint());
-        out->lineto(A->finalPoint() + point_a3);
-    } else if(handles == HM_SMOOTH && cubic) {
-        Geom::Ray ray(prev,A->initialPoint());
-        point_a1  = Geom::Point::polar(ray.angle(), max_lenght);
-        if(prev == Geom::Point(0,0)){
-            point_a1 = A->pointAt(1.0/3.0) + randomize(max_lenght);
-        }
-        ray.setPoints((*cubic)[3] + point_a3, (*cubic)[2] + point_a3);
-        point_a2  = randomize(max_lenght, ray.angle());
-        prev = (*cubic)[2] + point_a2;
-        out->moveto((*cubic)[0]);
-        out->curveto((*cubic)[0] + point_a1, (*cubic)[2] + point_a2 + point_a3, (*cubic)[3] + point_a3);
-    } else if(handles == HM_SMOOTH && !cubic) {
-        Geom::Ray ray(prev,A->initialPoint());
-        point_a1 = Geom::Point::polar(ray.angle(), max_lenght);
-        if(prev==Geom::Point(0,0)){
-            point_a1 = A->pointAt(1.0/3.0) + randomize(max_lenght);
+    if(handles == HM_SMOOTH) {
+        if (cubic) {
+            Geom::Ray ray(prev,A->initialPoint());
+            point_a1  = Geom::Point::polar(ray.angle(), max_lenght);
+            if(prev == Geom::Point(0,0)){
+                point_a1 = A->pointAt(1.0/3.0) + randomize(max_lenght);
+            }
+            ray.setPoints((*cubic)[3] + point_a3, (*cubic)[2] + point_a3);
+            point_a2  = randomize(max_lenght, ray.angle());
+            prev = (*cubic)[2] + point_a2;
+            out->moveto((*cubic)[0]);
+            out->curveto((*cubic)[0] + point_a1, (*cubic)[2] + point_a2 + point_a3, (*cubic)[3] + point_a3);
+        } else {
+            Geom::Ray ray(prev,A->initialPoint());
+            point_a1 = Geom::Point::polar(ray.angle(), max_lenght);
+            if(prev==Geom::Point(0,0)){
+                point_a1 = A->pointAt(1.0/3.0) + randomize(max_lenght);
+            }
+            ray.setPoints(A->finalPoint() + point_a3, A->pointAt((1.0/3.0) * 2) + point_a3);
+            point_a2  = randomize(max_lenght, ray.angle());
+            prev = A->pointAt((1.0/3.0) * 2) +  point_a2 + point_a3;
+            out->moveto(A->initialPoint());
+            out->curveto(A->initialPoint() + point_a1, A->pointAt((1.0/3.0) * 2) + point_a2 + point_a3, A->finalPoint() + point_a3);
         }
-        ray.setPoints(A->finalPoint() + point_a3, A->pointAt((1.0/3.0) * 2) + point_a3);
-        point_a2  = randomize(max_lenght, ray.angle());
-        prev = A->pointAt((1.0/3.0) * 2) +  point_a2 + point_a3;
+    } else if(handles == HM_RETRACT){
         out->moveto(A->initialPoint());
-        out->curveto(A->initialPoint() + point_a1, A->pointAt((1.0/3.0) * 2) + point_a2 + point_a3, A->finalPoint() + point_a3);
-    } else if (cubic) {
-        out->moveto((*cubic)[0]);
-        if(handles == HM_ALONG_NODES){
+        out->lineto(A->finalPoint() + point_a3);
+    } else if (handles == HM_ALONG_NODES) {
+        if(cubic){
+            out->moveto((*cubic)[0]);
             out->curveto((*cubic)[1] + last_move, (*cubic)[2] + point_a3, (*cubic)[3] + point_a3);
             last_move = point_a3;
         } else {
-            out->curveto((*cubic)[1] + point_a1, (*cubic)[2] + point_a2 + point_a3, (*cubic)[3] + point_a3);
+            out->moveto(A->initialPoint());
+            out->lineto(A->finalPoint() + point_a3);
         }
     } else if (handles == HM_RAND) {
         out->moveto(A->initialPoint());
         out->curveto(A->pointAt(0.3333) + point_a1, A->pointAt(0.6666) + point_a2 + point_a3,
                      A->finalPoint() + point_a3);
-    } else {
-        out->moveto(A->initialPoint());
-        out->lineto(A->finalPoint() + point_a3);
     }
     return out;
 }
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index e3ede2c2d..7e6a19d5a 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -45,7 +45,8 @@ public:
 
     virtual void doEffect(SPCurve *curve);
     virtual double sign(double randNumber);
-    virtual Geom::Point randomize(double max_lenght, double direction = 0);
+    virtual void doOnApply(SPLPEItem const* lpeitem);
+    virtual Geom::Point randomize(double max_lenght, bool is_node = false);
     virtual void doBeforeEffect(SPLPEItem const * lpeitem);
     virtual SPCurve const * addNodesAndJitter(Geom::Curve const * A, Geom::Point &prev, Geom::Point &last_move, double t, bool last);
     virtual SPCurve *jitter(Geom::Curve const * A,  Geom::Point &prev, Geom::Point &last_move);
@@ -60,7 +61,6 @@ private:
     RandomParam displace_y;
     RandomParam global_randomize;
     EnumParam<HandlesMethod> handles;
-    ScalarParam max_smooth_angle;
     BoolParam shift_nodes;
     BoolParam fixed_displacement;
     BoolParam spray_tool_friendly;
diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp
index f6842a030..2d79d5b34 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -29,7 +29,7 @@ LPESimplify::LPESimplify(LivePathEffectObject *lpeobject)
     : Effect(lpeobject),
       steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1),
       threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003),
-      smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.),
+      smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to perform a smooth"), "smooth_angles", &wr, this, 20.),
       helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5),
       simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths", &wr, this, false,
                               "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp
index ef616f802..f2ddd4929 100644
--- a/src/live_effects/lpe-taperstroke.cpp
+++ b/src/live_effects/lpe-taperstroke.cpp
@@ -408,9 +408,8 @@ Piecewise<D2<SBasis> > stretch_along(Piecewise<D2<SBasis> > pwd2_in, Geom::Path
             n = force_continuity(remove_short_cuts(n,.1));
 
             int nbCopies = 0;
-            double scaling = 1;
+            double scaling = (uskeleton.domain().extent() - toffset)/pattBndsX->extent();
             nbCopies = 1;
-            scaling = (uskeleton.domain().extent() - toffset)/pattBndsX->extent();
 
             double pattWidth = pattBndsX->extent() * scaling;
 
diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp
index 8326bd6f1..f2b756567 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -30,13 +30,13 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     elastic(_("Elastic"), _("Elastic transform mode"), "elastic", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
-    lock_lenght(_("Lock lenght"), _("Lock lenght to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
+    lock_lenght(_("Lock length"), _("Lock length to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     lock_angle(_("Lock angle"), _("Lock angle"), "lock_angle", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     flip_horizontal(_("Flip horizontal"), _("Flip horizontal"), "flip_horizontal", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     flip_vertical(_("Flip vertical"), _("Flip vertical"), "flip_vertical", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     start(_("Start"), _("Start point"), "start", &wr, this, "Start point"),
     end(_("End"), _("End point"), "end", &wr, this, "End point"),
-    strech(_("Strech"), _("Strech the result"), "strech", &wr, this, 1),
+    strech(_("Stretch"), _("Stretch the result"), "strech", &wr, this, 1),
     offset(_("Offset"), _("Offset from knots"), "offset", &wr, this, 0),
     first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1),
     last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1),
diff --git a/src/live_effects/parameter/filletchamferpointarray.cpp b/src/live_effects/parameter/filletchamferpointarray.cpp
index b089213fd..399307502 100644
--- a/src/live_effects/parameter/filletchamferpointarray.cpp
+++ b/src/live_effects/parameter/filletchamferpointarray.cpp
@@ -159,9 +159,8 @@ void FilletChamferPointArrayParam::recalculate_controlpoints_for_new_pwd2(
                     //todo: if the path remove some nodes whith the result of a straight
                     //line but with handles, the node inserted into dont fire the knot
                     // because is not handle as cusp node by  get_nodetype function
-                    bool this_is_line = true;
                     bool next_is_line = is_straight_curve(*curve_it1);
-                    this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
+                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
                     nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
                     if (this_is_line || next_is_line) {
                         nodetype = NODE_CUSP;
@@ -307,9 +306,8 @@ void FilletChamferPointArrayParam::recalculate_knots(
                         nodetype = NODE_NONE;
                     }
                 } else {
-                    bool this_is_line = true;
                     bool next_is_line = is_straight_curve(*curve_it1);
-                    this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
+                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
                     nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
                     if (this_is_line || next_is_line) {
                         nodetype = NODE_CUSP;
@@ -467,12 +465,12 @@ double FilletChamferPointArrayParam::len_to_rad(int index, double len)
     Geom::Point endArcPoint = B->toSBasis().valueAt(times[2]);
     Curve *knotCurve1 = A->portion(times[0], times[1]);
     Curve *knotCurve2 = B->portion(times[2], 1);
-    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve1);
+    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(knotCurve1);
     Ray ray1(startArcPoint, A->finalPoint());
     if (cubic1) {
         ray1.setPoints((*cubic1)[2], startArcPoint);
     }
-    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve2);
+    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(knotCurve2);
     Ray ray2(B->initialPoint(), endArcPoint);
     if (cubic2) {
         ray2.setPoints(endArcPoint, (*cubic2)[1]);
diff --git a/src/live_effects/parameter/originalpatharray.cpp b/src/live_effects/parameter/originalpatharray.cpp
index 78e061e66..9e03e2c02 100644
--- a/src/live_effects/parameter/originalpatharray.cpp
+++ b/src/live_effects/parameter/originalpatharray.cpp
@@ -215,7 +215,7 @@ void OriginalPathArrayParam::on_up_button_click()
         
         int i = -1;
         std::vector<PathAndDirection*>::iterator piter = _vector.begin();
-        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); piter = iter, i++, iter++) {
+        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); piter = iter, i++, ++iter) {
             if (*iter == row[_model->_colObject]) {
                 _vector.erase(iter);
                 _vector.insert(piter, row[_model->_colObject]);
@@ -241,7 +241,7 @@ void OriginalPathArrayParam::on_down_button_click()
         Gtk::TreeModel::Row row = *iter;
 
         int i = 0;
-        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); i++, iter++) {
+        for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); i++, ++iter) {
             if (*iter == row[_model->_colObject]) {
                 std::vector<PathAndDirection*>::iterator niter = _vector.erase(iter);
                 if (niter != _vector.end()) {
@@ -295,7 +295,7 @@ OriginalPathArrayParam::on_link_button_click()
     
     Inkscape::SVGOStringStream os;
     bool foundOne = false;
-    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); ++iter) {
         if (foundOne) {
             os << "|";
         } else {
@@ -330,7 +330,7 @@ void OriginalPathArrayParam::unlink(PathAndDirection* to)
 void OriginalPathArrayParam::remove_link(PathAndDirection* to)
 {
     unlink(to);
-    for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+    for (std::vector<PathAndDirection*>::iterator iter = _vector.begin(); iter != _vector.end(); ++iter) {
         if (*iter == to) {
             PathAndDirection *w = *iter;
             _vector.erase(iter);
@@ -455,7 +455,7 @@ gchar * OriginalPathArrayParam::param_getSVGValue() const
 {
     Inkscape::SVGOStringStream os;
     bool foundOne = false;
-    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); iter++) {
+    for (std::vector<PathAndDirection*>::const_iterator iter = _vector.begin(); iter != _vector.end(); ++iter) {
         if (foundOne) {
             os << "|";
         } else {