update to trunk

(bzr r13645.1.108)

4 files changed, 211 insertions, 342 deletions

diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index e8cbfcdbf..a889a12e6 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -20,7 +20,9 @@
 # include "config.h"
 #endif
 
+#include "live_effects/lpe-bendpath.h"
 #include "live_effects/lpe-patternalongpath.h"
+#include "live_effects/lpe-simplify.h"
 #include "display/canvas-bpath.h"
 #include "xml/repr.h"
 #include "svg/svg.h"
@@ -44,6 +46,7 @@
 #include "live_effects/lpe-powerstroke.h"
 #include "style.h"
 #include "ui/control-manager.h"
+#include "util/units.h"
 // clipboard support
 #include "ui/clipboard.h"
 #include "ui/tools/freehand-base.h"
@@ -212,7 +215,7 @@ static Glib::ustring const tool_name(FreehandBase *dc)
              : "/tools/freehand/pencil" );
 }
 
-static void spdc_paste_curve_as_freehand_shape(const SPCurve *c, FreehandBase *dc, SPItem *item)
+static void spdc_paste_curve_as_freehand_shape(Geom::PathVector const &newpath, FreehandBase *dc, SPItem *item)
 {
     using namespace Inkscape::LivePathEffect;
 
@@ -220,8 +223,7 @@ static void spdc_paste_curve_as_freehand_shape(const SPCurve *c, FreehandBase *d
 
     Effect::createAndApply(PATTERN_ALONG_PATH, dc->desktop->doc(), item);
     Effect* lpe = SP_LPE_ITEM(item)->getCurrentLPE();
-    gchar *svgd = sp_svg_write_path(c->get_pathvector());
-    static_cast<LPEPatternAlongPath*>(lpe)->pattern.paste_param_path(svgd);
+    static_cast<LPEPatternAlongPath*>(lpe)->pattern.set_new_value(newpath,true);
 }
 
 static void spdc_apply_powerstroke_shape(const std::vector<Geom::Point> & points, FreehandBase *dc, SPItem *item)
@@ -266,37 +268,83 @@ static void spdc_apply_powerstroke_shape(const std::vector<Geom::Point> & points
     lpe->getRepr()->setAttribute("offset_points", s.str().c_str());
 }
 
+static void spdc_apply_bend_shape(gchar const *svgd, FreehandBase *dc, SPItem *item)
+{
+    using namespace Inkscape::LivePathEffect;
+    if(!SP_LPE_ITEM(item)->hasPathEffectOfType(BEND_PATH)){
+        Effect::createAndApply(BEND_PATH, dc->desktop->doc(), item);
+    }
+    Effect* lpe = SP_LPE_ITEM(item)->getCurrentLPE();
+
+    // write bend parameters:
+    lpe->getRepr()->setAttribute("prop_scale", "1");
+    lpe->getRepr()->setAttribute("scale_y_rel", "false");
+    lpe->getRepr()->setAttribute("vertical", "false");
+    static_cast<LPEBendPath*>(lpe)->bend_path.paste_param_path(svgd);
+}
+
+static void spdc_apply_simplify(std::string threshold, FreehandBase *dc, SPItem *item)
+{
+    using namespace Inkscape::LivePathEffect;
+
+    Effect::createAndApply(SIMPLIFY, dc->desktop->doc(), item);
+    Effect* lpe = SP_LPE_ITEM(item)->getCurrentLPE();
+    // write simplify parameters:
+    lpe->getRepr()->setAttribute("steps", "1");
+    lpe->getRepr()->setAttribute("threshold", threshold);
+    lpe->getRepr()->setAttribute("smooth_angles", "360");
+    lpe->getRepr()->setAttribute("helper_size", "0");
+    lpe->getRepr()->setAttribute("simplifyindividualpaths", "false");
+    lpe->getRepr()->setAttribute("simplifyJustCoalesce", "false");
+}
+
+enum shapeType { NONE, TRIANGLE_IN, TRIANGLE_OUT, ELLIPSE, CLIPBOARD, BEND_CLIPBOARD, LAST_APPLIED };
+static shapeType previous_shape_type = NONE;
+
 static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item, SPCurve *curve)
 {
     using namespace Inkscape::LivePathEffect;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     if (item && SP_IS_LPE_ITEM(item)) {
+        bool simplify = prefs->getInt(tool_name(dc) + "/simplify", 0);
+        if(simplify){
+            double tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0);
+            tol = tol/(100.0*(102.0-tol));
+            std::ostringstream ss;
+            ss << tol;
+            spdc_apply_simplify(ss.str(), dc, item);
+            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
+        }
         if (prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1) {
             Effect::createAndApply(SPIRO, dc->desktop->doc(), item);
         }
-        //add the bspline node in the waiting effects
+
         if (prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2) {
             Effect::createAndApply(BSPLINE, dc->desktop->doc(), item);
         }
+        SPShape *sp_shape = dynamic_cast<SPShape *>(item);
+        if (sp_shape) {
+            curve = sp_shape->getCurve();
+        }
 
         //Store the clipboard path to apply in the future without the use of clipboard
         static Geom::PathVector previous_shape_pathv;
-        enum shapeType { NONE, TRIANGLE_IN, TRIANGLE_OUT, ELLIPSE, CLIPBOARD, LAST_APPLIED };
-        static shapeType previous_shape_type = NONE;
-
 
         shapeType shape = (shapeType)prefs->getInt(tool_name(dc) + "/shape", 0);
         bool shape_applied = false;
         SPCSSAttr *css_item = sp_css_attr_from_object(item, SP_STYLE_FLAG_ALWAYS);
         const char *cstroke = sp_repr_css_property(css_item, "stroke", "none");
+        static SPItem *bend_item;
 
 #define SHAPE_LENGTH 10
 #define SHAPE_HEIGHT 10
 
+
         if(shape == LAST_APPLIED){
+
             shape = previous_shape_type;
-            if(shape == CLIPBOARD){
+            if(shape == CLIPBOARD || shape == BEND_CLIPBOARD){
                 shape = LAST_APPLIED;
             }
         }
@@ -337,7 +385,7 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
                 c->curveto(SHAPE_LENGTH, (1 + C1) * SHAPE_HEIGHT/2, (1 + C1) * SHAPE_LENGTH/2, SHAPE_HEIGHT, SHAPE_LENGTH/2, SHAPE_HEIGHT);
                 c->curveto((1 - C1) * SHAPE_LENGTH/2, SHAPE_HEIGHT, 0, (1 + C1) * SHAPE_HEIGHT/2, 0, SHAPE_HEIGHT/2);
                 c->closepath();
-                spdc_paste_curve_as_freehand_shape(c, dc, item);
+                spdc_paste_curve_as_freehand_shape(c->get_pathvector(), dc, item);
                 c->unref();
 
                 shape_applied = true;
@@ -345,26 +393,90 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
             }
             case CLIPBOARD:
             {
-                // take shape from clipboard; TODO: catch the case where clipboard is empty
-                Effect::createAndApply(PATTERN_ALONG_PATH, dc->desktop->doc(), item);
-                Effect* lpe = SP_LPE_ITEM(item)->getCurrentLPE();
-                static_cast<LPEPatternAlongPath*>(lpe)->pattern.on_paste_button_click();
+                // take shape from clipboard;
                 Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
-                Glib::ustring svgd = cm->getPathParameter(SP_ACTIVE_DESKTOP);
-                previous_shape_pathv = sp_svg_read_pathv(svgd.data());
-
-                shape_applied = true;
+                if(cm->paste(SP_ACTIVE_DESKTOP,true) == true){
+                    SPItem * pasted_clipboard = dc->selection->singleItem();
+                    if(pasted_clipboard){
+                        Inkscape::XML::Node *pasted_clipboard_root = pasted_clipboard->getRepr();
+                        Inkscape::XML::Node *path = sp_repr_lookup_name(pasted_clipboard_root, "svg:path", -1); // unlimited search depth
+                        if ( path != NULL ) {
+                            gchar const *svgd = path->attribute("d");
+                            dc->selection->remove(SP_OBJECT(pasted_clipboard));
+                            previous_shape_pathv =  sp_svg_read_pathv(svgd);
+                            previous_shape_pathv *= pasted_clipboard->transform;
+                            spdc_paste_curve_as_freehand_shape(previous_shape_pathv, dc, item);
+
+                            shape = CLIPBOARD;
+                            shape_applied = true;
+                            pasted_clipboard->deleteObject();
+                        } else {
+                            shape = NONE;
+                        }
+                    } else {
+                        shape = NONE;
+                    }
+                } else {
+                    shape = NONE;
+                }
+                break;
+            }
+            case BEND_CLIPBOARD:
+            {
+                Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
+                if(cm->paste(SP_ACTIVE_DESKTOP,true) == true){
+                    gchar const *svgd = item->getRepr()->attribute("d");
+                    bend_item = dc->selection->singleItem();
+                    if(bend_item){
+                        bend_item->moveTo(item,false);
+                        bend_item->transform.setTranslation(Geom::Point());
+                        spdc_apply_bend_shape(svgd, dc, bend_item);
+                        dc->selection->add(SP_OBJECT(bend_item));
+
+                        shape = BEND_CLIPBOARD;
+                    } else {
+                        shape = NONE;
+                    }
+                } else {
+                    shape = NONE;
+                }
                 break;
             }
             case LAST_APPLIED:
             {
-                if(previous_shape_pathv.size() != 0){
-                    SPCurve * c = new SPCurve();
-                    c->set_pathvector(previous_shape_pathv);
-                    spdc_paste_curve_as_freehand_shape(c, dc, item);
-                    c->unref();
-
-                    shape_applied = true;
+                if(previous_shape_type == CLIPBOARD){
+                    if(previous_shape_pathv.size() != 0){
+                        spdc_paste_curve_as_freehand_shape(previous_shape_pathv, dc, item);
+
+                        shape_applied = true;
+                        shape = CLIPBOARD;
+                    } else{
+                        shape = NONE;
+                    }
+                } else {
+                    if(bend_item != NULL && bend_item->getRepr() != NULL){
+                        gchar const *svgd = item->getRepr()->attribute("d");
+                        dc->selection->add(SP_OBJECT(bend_item));
+                        sp_selection_duplicate(dc->desktop);
+                        dc->selection->remove(SP_OBJECT(bend_item));
+                        bend_item = dc->selection->singleItem();
+                        if(bend_item){
+                            bend_item->moveTo(item,false);
+                            Geom::Coord expansion_X = bend_item->transform.expansionX();
+                            Geom::Coord expansion_Y = bend_item->transform.expansionY();
+                            bend_item->transform = Geom::Affine(1,0,0,1,0,0);
+                            bend_item->transform.setExpansionX(expansion_X);
+                            bend_item->transform.setExpansionY(expansion_Y);
+                            spdc_apply_bend_shape(svgd, dc, bend_item);
+                            dc->selection->add(SP_OBJECT(bend_item));
+
+                            shape = BEND_CLIPBOARD;
+                        } else {
+                            shape = NONE;
+                        }
+                    } else {
+                        shape = NONE;
+                    }
                 }
                 break;
             }
@@ -643,7 +755,6 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
 static void spdc_flush_white(FreehandBase *dc, SPCurve *gc)
 {
     SPCurve *c;
-
     if (dc->white_curves) {
         g_assert(dc->white_item);
         c = SPCurve::concat(dc->white_curves);
@@ -695,14 +806,17 @@ static void spdc_flush_white(FreehandBase *dc, SPCurve *gc)
             // Attach repr
             SPItem *item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
 
-            // we finished the path; now apply any waiting LPEs or freehand shapes
             spdc_check_for_and_apply_waiting_LPE(dc, item, c);
-
-            dc->selection->set(repr);
+            if(previous_shape_type != BEND_CLIPBOARD){
+                dc->selection->set(repr);
+            }
             Inkscape::GC::release(repr);
             item->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
             item->updateRepr();
             item->doWriteTransform(item->getRepr(), item->transform, NULL, true);
+            if(previous_shape_type == BEND_CLIPBOARD){
+                repr->parent()->removeChild(repr);
+            }
         }
 
         DocumentUndo::done(doc, SP_IS_PEN_CONTEXT(dc)? SP_VERB_CONTEXT_PEN : SP_VERB_CONTEXT_PENCIL,
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index 827dbf5c3..2ed366a7d 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -84,7 +84,7 @@ namespace Tools {
 static Geom::Point pen_drag_origin_w(0, 0);
 static bool pen_within_tolerance = false;
 static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical
-const double HANDLE_CUBIC_GAP = 0.01;
+const double HANDLE_CUBIC_GAP = 0.001;
 
 const std::string& PenTool::getPrefsPath() {
     return PenTool::prefsPath;
@@ -268,6 +268,9 @@ void PenTool::_endpointSnap(Geom::Point &p, guint const state) const {
     if ((state & GDK_CONTROL_MASK) && !this->polylines_paraxial) { //CTRL enables angular snapping
         if (this->npoints > 0) {
             spdc_endpoint_snap_rotation(this, p, this->p[0], state);
+        } else {
+            boost::optional<Geom::Point> origin = boost::optional<Geom::Point>();
+            spdc_endpoint_snap_free(this, p, origin, state);
         }
     } else {
         // We cannot use shift here to disable snapping because the shift-key is already used
@@ -379,11 +382,12 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
         if( anchor && anchor == this->sa && this->green_curve->is_empty()){
             //remove the following line to avoid having one node on top of another
             _finishSegment(event_dt, bevent.state);
-            _finish( false);
+            _finish(true);
             return true;
         }
         return false;
     } 
+    
     bool ret = false;
     if (bevent.button == 1 && !this->space_panning
         // make sure this is not the last click for a waiting LPE (otherwise we want to finish the path)
@@ -857,7 +861,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
 bool PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
     bool ret = false;
     // only end on LMB double click. Otherwise horizontal scrolling causes ending of the path
-    if (this->npoints != 0 && bevent.button == 1) {
+    if (this->npoints != 0 && bevent.button == 1 && this->state != PenTool::CLOSE) {
         this->_finish(false);
         ret = true;
     }
@@ -1714,9 +1718,9 @@ void PenTool::_bsplineSpiroBuild()
         //Effect *spr = static_cast<Effect*> ( new LPEbspline(lpeobj) );
         //spr->doEffect(curve);
         if(this->bspline){
-            this->_bsplineDoEffect(curve);
+            LivePathEffect::sp_bspline_do_effect(curve, 0);
         }else{
-            this->_spiroDoEffect(curve);
+            LivePathEffect::sp_spiro_do_effect(curve);
         }
 
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), curve);   
@@ -1740,257 +1744,6 @@ void PenTool::_bsplineSpiroBuild()
     }
 }
 
-//from LPE BSPLINE:
-void PenTool::_bsplineDoEffect(SPCurve * curve)
-{
-    //const double NO_POWER = 0.0;
-    const double DEFAULT_START_POWER = 0.3334;
-    const double DEFAULT_END_POWER = 0.6667;
-    if (curve->get_segment_count() < 1) {
-        return;
-    }
-    // Make copy of old path as it is changed during processing
-    Geom::PathVector const original_pathv = curve->get_pathvector();
-
-    curve->reset();
-
-    for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
-            path_it != original_pathv.end(); ++path_it) {
-        if (path_it->empty()) {
-            continue;
-        }
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        SPCurve *curve_n = new SPCurve();
-        Geom::Point previousNode(0, 0);
-        Geom::Point node(0, 0);
-        Geom::Point point_at1(0, 0);
-        Geom::Point point_at2(0, 0);
-        Geom::Point next_point_at1(0, 0);
-        Geom::D2<Geom::SBasis> sbasis_in;
-        Geom::D2<Geom::SBasis> sbasis_out;
-        Geom::D2<Geom::SBasis> sbasis_helper;
-        Geom::CubicBezier const *cubic = NULL;
-        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();
-            }
-        }
-        curve_n->moveto(curve_it1->initialPoint());
-        while (curve_it1 != curve_endit) {
-            SPCurve *in = new SPCurve();
-            in->moveto(curve_it1->initialPoint());
-            in->lineto(curve_it1->finalPoint());
-            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-            if (cubic) {
-                sbasis_in = in->first_segment()->toSBasis();
-                if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
-                    point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER);
-                } else {
-                    point_at1 = sbasis_in.valueAt(Geom::nearest_time((*cubic)[1], *in->first_segment()));
-                }
-                if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) {
-                    point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER);
-                } else {
-                    point_at2 = sbasis_in.valueAt(Geom::nearest_time((*cubic)[2], *in->first_segment()));
-                }
-            } else {
-                point_at1 = in->first_segment()->initialPoint();
-                point_at2 = in->first_segment()->finalPoint();
-            }
-            in->reset();
-            delete in;
-            if ( curve_it2 != curve_endit ) {
-                SPCurve *out = new SPCurve();
-                out->moveto(curve_it2->initialPoint());
-                out->lineto(curve_it2->finalPoint());
-                cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
-                if (cubic) {
-                    sbasis_out = out->first_segment()->toSBasis();
-                    if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
-                        next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER);
-                    } else {
-                        next_point_at1 = sbasis_out.valueAt(Geom::nearest_time((*cubic)[1], *out->first_segment()));
-                    }
-                } else {
-                    next_point_at1 = out->first_segment()->initialPoint();
-                }
-                out->reset();
-                delete out;
-            }
-            if (path_it->closed() && curve_it2 == curve_endit) {
-                SPCurve *start = new SPCurve();
-                start->moveto(path_it->begin()->initialPoint());
-                start->lineto(path_it->begin()->finalPoint());
-                Geom::D2<Geom::SBasis> sbasis_start = start->first_segment()->toSBasis();
-                SPCurve *line_helper = new SPCurve();
-                cubic = dynamic_cast<Geom::CubicBezier const *>(&*path_it->begin());
-                if (cubic) {
-                    line_helper->moveto(sbasis_start.valueAt(
-                                           Geom::nearest_time((*cubic)[1], *start->first_segment())));
-                } else {
-                    line_helper->moveto(start->first_segment()->initialPoint());
-                }
-                start->reset();
-                delete start;
-
-                SPCurve *end = new SPCurve();
-                end->moveto(curve_it1->initialPoint());
-                end->lineto(curve_it1->finalPoint());
-                Geom::D2<Geom::SBasis> sbasis_end = end->first_segment()->toSBasis();
-                cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-                if (cubic) {
-                    line_helper->lineto(sbasis_end.valueAt(
-                                           Geom::nearest_time((*cubic)[2], *end->first_segment())));
-                } else {
-                    line_helper->lineto(end->first_segment()->finalPoint());
-                }
-                end->reset();
-                delete end;
-                sbasis_helper = line_helper->first_segment()->toSBasis();
-                line_helper->reset();
-                delete line_helper;
-                node = sbasis_helper.valueAt(0.5);
-                curve_n->curveto(point_at1, point_at2, node);
-                curve_n->move_endpoints(node, node);
-            } else if ( curve_it2 == curve_endit) {
-                curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint());
-                curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint());
-            } else {
-                SPCurve *line_helper = new SPCurve();
-                line_helper->moveto(point_at2);
-                line_helper->lineto(next_point_at1);
-                sbasis_helper = line_helper->first_segment()->toSBasis();
-                line_helper->reset();
-                delete line_helper;
-                previousNode = node;
-                node = sbasis_helper.valueAt(0.5);
-                Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-                if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) {
-                    node = curve_it1->finalPoint();
-                }
-                curve_n->curveto(point_at1, point_at2, node);
-            }
-            ++curve_it1;
-            ++curve_it2;
-        }
-        //y cerramos la curva
-        if (path_it->closed()) {
-            curve_n->closepath_current();
-        }
-        curve->append(curve_n, false);
-        curve_n->reset();
-        delete curve_n;
-    }
-}
-
-//Spiro function cloned from lpe-spiro.cpp
-// commenting the function "doEffect" from src/live_effects/lpe-spiro.cpp
-void PenTool::_spiroDoEffect(SPCurve * curve)
-{
-    using Geom::X;
-    using Geom::Y;
-
-    Geom::PathVector const original_pathv = curve->get_pathvector();
-    guint len = curve->get_segment_count() + 2;
-
-    curve->reset();
-    Spiro::spiro_cp *path = g_new (Spiro::spiro_cp, len);
-    int ip = 0;
-
-    for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
-        if (path_it->empty())
-            continue;
-
-        {
-            Geom::Point p = path_it->front().pointAt(0);
-            path[ip].x = p[X];
-            path[ip].y = p[Y];
-            path[ip].ty = '{' ;
-            ip++;
-        }
-
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
-
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed()) {
-            const Geom::Curve &closingline = path_it->back_closed(); 
-            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                curve_endit = path_it->end_open();
-            }
-        }
-
-        while ( curve_it2 != curve_endit )
-        {
-            Geom::Point p = curve_it1->finalPoint();
-            path[ip].x = p[X];
-            path[ip].y = p[Y];
-
-            bool this_is_line = is_straight_curve(*curve_it1);
-            bool next_is_line = is_straight_curve(*curve_it2);
-
-            Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, *curve_it2);
-
-            if ( nodetype == Geom::NODE_SMOOTH || nodetype == Geom::NODE_SYMM )
-            {
-                if (this_is_line && !next_is_line) {
-                    path[ip].ty = ']';
-                } else if (next_is_line && !this_is_line) {
-                    path[ip].ty = '[';
-                } else {
-                    path[ip].ty = 'c';
-                }
-            } else {
-                path[ip].ty = 'v';
-            }
-
-            ++curve_it1;
-            ++curve_it2;
-            ip++;
-        }
-
-        Geom::Point p = curve_it1->finalPoint();
-        path[ip].x = p[X];
-        path[ip].y = p[Y];
-        if (path_it->closed()) {
-            Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, path_it->front());
-            switch (nodetype) {
-                case Geom::NODE_NONE:
-                    path[ip].ty = '}';
-                    ip++;
-                    break;
-                case Geom::NODE_CUSP:
-                    path[0].ty = path[ip].ty = 'v';
-                    break;
-                case Geom::NODE_SMOOTH:
-                case Geom::NODE_SYMM:
-                    path[0].ty = path[ip].ty = 'c';
-                    break;
-            }
-        } else {
-            path[ip].ty = '}';
-            ip++;
-        }
-
-        int sp_len = ip;
-        Spiro::spiro_run(path, sp_len, *curve);
-        ip = 0;
-    }
-
-    g_free (path);
-}
-
 void PenTool::_setSubsequentPoint(Geom::Point const p, bool statusbar, guint status) {
     g_assert( this->npoints != 0 );
 
diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h
index 0ae16caf0..5a21e3bac 100644
--- a/src/ui/tools/pen-tool.h
+++ b/src/ui/tools/pen-tool.h
@@ -22,21 +22,21 @@ namespace Tools {
  */
 class PenTool : public FreehandBase {
 public:
-	PenTool();
-	PenTool(gchar const *const *cursor_shape, gint hot_x, gint hot_y);
-	virtual ~PenTool();
-
-	enum Mode {
-	    MODE_CLICK,
-	    MODE_DRAG
-	};
-
-	enum State {
-	    POINT,
-	    CONTROL,
-	    CLOSE,
-	    STOP
-	};
+    PenTool();
+    PenTool(gchar const *const *cursor_shape, gint hot_x, gint hot_y);
+    virtual ~PenTool();
+
+    enum Mode {
+        MODE_CLICK,
+        MODE_DRAG
+    };
+
+    enum State {
+        POINT,
+        CONTROL,
+        CLOSE,
+        STOP
+    };
 
     Geom::Point p[5];
 
@@ -66,28 +66,28 @@ public:
     
     bool events_disabled;
 
-	static const std::string prefsPath;
+    static const std::string prefsPath;
 
-	virtual const std::string& getPrefsPath();
+    virtual const std::string& getPrefsPath();
 
-	int nextParaxialDirection(Geom::Point const &pt, Geom::Point const &origin, guint state) const;
-	void setPolylineMode();
-	bool hasWaitingLPE();
+    int nextParaxialDirection(Geom::Point const &pt, Geom::Point const &origin, guint state) const;
+    void setPolylineMode();
+    bool hasWaitingLPE();
     void waitForLPEMouseClicks(Inkscape::LivePathEffect::EffectType effect_type, unsigned int num_clicks, bool use_polylines = true);
 
 protected:
-	virtual void setup();
-	virtual void finish();
-	virtual void set(const Inkscape::Preferences::Entry& val);
-	virtual bool root_handler(GdkEvent* event);
-	virtual bool item_handler(SPItem* item, GdkEvent* event);
+    virtual void setup();
+    virtual void finish();
+    virtual void set(const Inkscape::Preferences::Entry& val);
+    virtual bool root_handler(GdkEvent* event);
+    virtual bool item_handler(SPItem* item, GdkEvent* event);
 
 private:
-	bool _handleButtonPress(GdkEventButton const &bevent);
-	bool _handleMotionNotify(GdkEventMotion const &mevent);
-	bool _handleButtonRelease(GdkEventButton const &revent);
-	bool _handle2ButtonPress(GdkEventButton const &bevent);
-	bool _handleKeyPress(GdkEvent *event);
+    bool _handleButtonPress(GdkEventButton const &bevent);
+    bool _handleMotionNotify(GdkEventMotion const &mevent);
+    bool _handleButtonRelease(GdkEventButton const &revent);
+    bool _handle2ButtonPress(GdkEventButton const &bevent);
+    bool _handleKeyPress(GdkEvent *event);
     //adds spiro & bspline modes
     void _penContextSetMode(guint mode);
     //this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro
@@ -110,40 +110,36 @@ private:
     void _bsplineSpiroEndAnchorOn();
     //closes the curve with the last node in CUSP mode
     void _bsplineSpiroEndAnchorOff();
-    //CHECK: join all the curves "in game" and we call doEffect function
+    //apply the effect
     void _bsplineSpiroBuild();
-    //function bspline cloned from lpe-bspline.cpp
-    void _bsplineDoEffect(SPCurve * curve);
-    //function spiro cloned from lpe-spiro.cpp
-    void _spiroDoEffect(SPCurve * curve);
-
-	void _setInitialPoint(Geom::Point const p);
-	void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0);
-	void _setCtrl(Geom::Point const p, guint state);
-	void _finishSegment(Geom::Point p, guint state);
+
+    void _setInitialPoint(Geom::Point const p);
+    void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0);
+    void _setCtrl(Geom::Point const p, guint state);
+    void _finishSegment(Geom::Point p, guint state);
     bool _undoLastPoint();
 
-	void _finish(gboolean closed);
+    void _finish(gboolean closed);
 
-	void _resetColors();
+    void _resetColors();
 
-	void _disableEvents();
-	void _enableEvents();
+    void _disableEvents();
+    void _enableEvents();
 
-	void _setToNearestHorizVert(Geom::Point &pt, guint const state, bool snap) const;
+    void _setToNearestHorizVert(Geom::Point &pt, guint const state, bool snap) const;
 
-	void _setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_to_compare, gchar const *message);
+    void _setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_to_compare, gchar const *message);
 
-	void _lastpointToLine();
-	void _lastpointToCurve();
-	void _lastpointMoveScreen(gdouble x, gdouble y);
-	void _lastpointMove(gdouble x, gdouble y);
-	void _redrawAll();
+    void _lastpointToLine();
+    void _lastpointToCurve();
+    void _lastpointMoveScreen(gdouble x, gdouble y);
+    void _lastpointMove(gdouble x, gdouble y);
+    void _redrawAll();
 
-	void _endpointSnapHandle(Geom::Point &p, guint const state) const;
-	void _endpointSnap(Geom::Point &p, guint const state) const;
+    void _endpointSnapHandle(Geom::Point &p, guint const state) const;
+    void _endpointSnap(Geom::Point &p, guint const state) const;
 
-	void _cancel();
+    void _cancel();
 };
 
 }
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index 16c26546f..bfb1c67f0 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -635,8 +635,11 @@ void PencilTool::_interpolate() {
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double const tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0) * 0.4;
-    double const tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
-
+    double tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
+    bool simplify = prefs->getInt("/tools/freehand/pencil/simplify", 0);
+    if(simplify){
+        tolerance_sq = 0;
+    }
     g_assert(is_zero(this->req_tangent) || is_unit_vector(this->req_tangent));
 
     this->green_curve->reset();
@@ -703,8 +706,11 @@ void PencilTool::_sketchInterpolate() {
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double const tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0) * 0.4;
-    double const tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
-
+    double tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
+    bool simplify = prefs->getInt("/tools/freehand/pencil/simplify", 0);
+    if(simplify){
+        tolerance_sq = 0;
+    }
     bool average_all_sketches = prefs->getBool("/tools/freehand/pencil/average_all_sketches", true);
 
     g_assert(is_zero(this->req_tangent) || is_unit_vector(this->req_tangent));