Merge lp:~inkscape.dev/inkscape/roughen into lp:~inkscape.dev/inkscape/trunk

[Jabiertxof]

Add a new LPE that mix this extensions: "add nodes" + "Jitter nodes"

An aidea by Josh Andler.

[lp:~inkscape.dev/inkscape/roughen]

13308. By Jabiertxof <email address hidden> on 2014-04-27

fix a bug in closed paths

13309. By Jabiertxof <email address hidden> on 2014-04-27

fix a bug in closed paths

13310. By Jabiertxof <email address hidden> on 2014-04-27

improving closed paths

13311. By Jabiertxof <email address hidden> on 2014-04-27

improving closed paths

13312. By Jabiertxof <email address hidden> on 2014-04-27

improving closed paths

13313. By Jabiertxof <email address hidden> on 2014-04-27

Now the shift X&Y values accept only positive values and the random result are divided by 2 and randomly *-1

13314. By Jabiertxof <email address hidden> on 2014-04-27

Removed the division by 2 in the random Shift values, think is more clear,now sifth X sice from pont

13315. By Jabiertxof <email address hidden> on 2014-04-27

Removed the division by 2 in the random Shift values, now shift X&Y size to ponts

13316. By Jabiertxof <email address hidden> on 2014-04-27

update to trunk

13317. By Jabiertxof <email address hidden> on 2014-04-28

Fixed unit problem in subdivide by max lenght

13318. By Jabiertxof <email address hidden> on 2014-04-28

Now handles no subdivision - number of segments = 1

13319. By Jabiertxof <email address hidden> on 2014-04-28

2 attempt: Now handles no subdivision - number of segments = 1

13320. By Jabiertxof <email address hidden> on 2014-04-28

fixing closing straight lines whith no subdivision

13321. By Jabiertxof <email address hidden> on 2014-04-28

Clang Format code

13322. By Jabiertxof <email address hidden> on 2014-04-28

update to trunk

13323. By Jabiertxof <email address hidden> on 2014-05-07

update to trunk

13324. By Jabiertxof <email address hidden> on 2014-07-07

update to trunk

13325. By Jabiertxof <email address hidden> on 2014-07-23

update to trunk

13326. By Jabiertxof <email address hidden> on 2014-07-29

update to trunk

13327. By Jabiertxof <email address hidden> on 2014-07-30

Fix a bug pointed by LiamW

13328. By Jabiertxof <email address hidden> on 2014-09-14

Fix code and add crack parameters

13329. By Jabiertxof <email address hidden> on 2014-09-14

update to trunk

13330. By Jabiertxof <email address hidden> on 2014-09-14

Reorder widgets

13331. By Jabiertxof <email address hidden> on 2014-09-14

fix bug compiling

13332. By Jabiertxof <email address hidden> on 2014-09-14

fix bug compiling pointed by su_v

13333. By Jabiertxof <email address hidden> on 2014-09-14

Fix a bug in crack percent

13334. By Jabiertxof <email address hidden> on 2014-09-14

Fix a/nother bug in crack percent

13335. By Jabiertxof <email address hidden> on 2014-09-14

Code cleanup and fixed percent craked value

13336. By Jabiertxof <email address hidden> on 2014-09-14

Fix crack percent calculation

13337. By Jabiertxof <email address hidden> on 2014-09-14

Fix crack percent calculation II

13338. By Jabiertxof <email address hidden> on 2014-09-14

Fix crack percent calculation III

13339. By Jabiertxof <email address hidden> on 2014-09-15

Fixed crack percent calculation

13340. By Jabiertxof <email address hidden> on 2014-09-15

removed craked work, waiting to KK work on boolean operations, also some code formating

13341. By Jabiertxof <email address hidden> on 2014-09-15

update to trunk

[su_v (suv-lp)]

roughen was added to experimental in r13447
http://bazaar.launchpad.net/~inkscape.dev/inkscape/experimental/revision/13447

experimental was merged into trunk in r13641
http://bazaar.launchpad.net/~inkscape.dev/inkscape/trunk/revision/13641

Changing status to 'Merged'.

=== modified file 'po/POTFILES.skip'
--- po/POTFILES.skip	2010-01-14 08:13:09 +0000
+++ po/POTFILES.skip	2014-09-15 15:24:25 +0000
@@ -25,6 +25,7 @@
 src/live_effects/lpe-tangent_to_curve.cpp
 src/live_effects/lpe-test-doEffect-stack.cpp
 src/live_effects/lpe-text_label.cpp
+src/live_effects/lpe-simplify.cpp
 src/lpe-tool-context.cpp
 src/ui/dialog/session-player.cpp
 src/ui/dialog/whiteboard-connect.cpp
 
=== modified file 'src/live_effects/CMakeLists.txt'
--- src/live_effects/CMakeLists.txt	2012-03-23 21:02:03 +0000
+++ src/live_effects/CMakeLists.txt	2014-09-15 15:24:25 +0000
@@ -32,6 +32,7 @@
 	# lpe-skeleton.cpp
 	lpe-sketch.cpp
 	lpe-spiro.cpp
+	lpe-roughen.cpp
 	lpe-tangent_to_curve.cpp
 	lpe-test-doEffect-stack.cpp
 	lpe-text_label.cpp
@@ -52,6 +53,7 @@
 	parameter/powerstrokepointarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
+	parameter/togglebutton.cpp
 	parameter/unit.cpp
 	parameter/vector.cpp
 
@@ -92,6 +94,7 @@
 	lpe-skeleton.h
 	lpe-sketch.h
 	lpe-spiro.h
+	lpe-roughen.h
 	lpe-tangent_to_curve.h
 	lpe-test-doEffect-stack.h
 	lpe-text_label.h
@@ -113,6 +116,7 @@
 	parameter/powerstrokepointarray.h
 	parameter/random.h
 	parameter/text.h
+	parameter/togglebutton.h
 	parameter/unit.h
 	parameter/vector.h
 
 
=== modified file 'src/live_effects/Makefile_insert'
--- src/live_effects/Makefile_insert	2012-03-23 21:02:03 +0000
+++ src/live_effects/Makefile_insert	2014-09-15 15:24:25 +0000
@@ -40,6 +40,8 @@
 	live_effects/lpe-test-doEffect-stack.h	\
 	live_effects/lpe-lattice.cpp	\
 	live_effects/lpe-lattice.h	\
+	live_effects/lpe-roughen.cpp	\
+	live_effects/lpe-roughen.h	\
 	live_effects/lpe-envelope.cpp	\
 	live_effects/lpe-envelope.h	\
 	live_effects/lpe-spiro.cpp	\
 
=== modified file 'src/live_effects/effect-enum.h'
--- src/live_effects/effect-enum.h	2012-01-12 21:06:16 +0000
+++ src/live_effects/effect-enum.h	2014-09-15 15:24:25 +0000
@@ -28,6 +28,7 @@
     PERSPECTIVE_PATH,
     SPIRO,
     LATTICE,
+    ROUGHEN,
     ENVELOPE,
     CONSTRUCT_GRID,
     PERP_BISECTOR,
 
=== modified file 'src/live_effects/effect.cpp'
--- src/live_effects/effect.cpp	2014-05-05 08:40:12 +0000
+++ src/live_effects/effect.cpp	2014-09-15 15:24:25 +0000
@@ -25,6 +25,7 @@
 #include "live_effects/lpe-perspective_path.h"
 #include "live_effects/lpe-spiro.h"
 #include "live_effects/lpe-lattice.h"
+#include "live_effects/lpe-roughen.h"
 #include "live_effects/lpe-envelope.h"
 #include "live_effects/lpe-constructgrid.h"
 #include "live_effects/lpe-perp_bisector.h"
@@ -120,6 +121,7 @@
 /* 0.49 */
     {POWERSTROKE,           N_("Power stroke"), "powerstroke"},
     {CLONE_ORIGINAL,        N_("Clone original path"), "clone_original"},
+    {ROUGHEN,               N_("Roughen"),     "roughen"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -243,6 +245,9 @@
         case CLONE_ORIGINAL:
             neweffect = static_cast<Effect*> ( new LPECloneOriginal(lpeobj) );
             break;
+        case ROUGHEN:
+            neweffect = static_cast<Effect*> ( new LPERoughen(lpeobj) );
+            break;
         default:
             g_warning("LivePathEffect::Effect::New   called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
@@ -496,7 +501,16 @@
 
     if (!SP_IS_SHAPE(lpeitem)) {
 //        g_print ("How to handle helperpaths for non-shapes?\n"); // non-shapes are for example SPGroups.
-        return hp_vec;
+//        return hp_vec;
+    }
+
+
+    // TODO: we can probably optimize this by using a lot more references
+    //       rather than copying PathVectors all over the place
+    if (SP_IS_SHAPE(lpeitem) && show_orig_path) {
+        // add original path to helperpaths
+        SPCurve* curve = SP_SHAPE(lpeitem)->getCurve ();
+        hp_vec.push_back(curve->get_pathvector());
     }
 
     // add indicators provided by the effect itself
 
=== added file 'src/live_effects/lpe-roughen.cpp'
--- src/live_effects/lpe-roughen.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-roughen.cpp	2014-09-15 15:24:25 +0000
@@ -0,0 +1,349 @@
+/**
+ * @file
+ * Roughen LPE implementation. Creates roughen paths.
+ */
+/* Authors:
+ *   Jabier Arraiza Cenoz <[e-mail]>
+ *
+ * Thanks to all people involved specialy to Josh Andler for the idea and to the
+ * original extensions authors.
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <gtkmm.h>
+
+#include "live_effects/lpe-roughen.h"
+#include "display/curve.h"
+#include "live_effects/parameter/parameter.h"
+#include "helper/geom.h"
+#include <glibmm/i18n.h>
+#include <cmath>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+static const Util::EnumData<DivisionMethod> DivisionMethodData[DM_END] = {
+    { DM_SEGMENTS, N_("By number of segments"), "segments" },
+    { DM_SIZE, N_("By max. segment size"), "size" }
+};
+static const Util::EnumDataConverter<DivisionMethod>
+DMConverter(DivisionMethodData, DM_END);
+
+LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
+    : Effect(lpeobject),
+      // initialise your parameters here:
+      unit(_("Unit"), _("Unit"), "unit", &wr, this),
+      method(_("Method"), _("Division method"), "method", DMConverter, &wr,
+             this, DM_SEGMENTS),
+      maxSegmentSize(_("Max. segment size"), _("Max. segment size"),
+                     "maxSegmentSize", &wr, this, 10.),
+      segments(_("Number of segments"), _("Number of segments"), "segments",
+               &wr, this, 2),
+      displaceX(_("Max. displacement in X"), _("Max. displacement in X"),
+                "displaceX", &wr, this, 10.),
+      displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"),
+                "displaceY", &wr, this, 10.),
+      shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this,
+                 true),
+      shiftNodeHandles(_("Shift node handles"), _("Shift node handles"),
+                       "shiftNodeHandles", &wr, this, true)
+{
+    registerParameter(&unit);
+    registerParameter(&method);
+    registerParameter(&maxSegmentSize);
+    registerParameter(&segments);
+    registerParameter(&displaceX);
+    registerParameter(&displaceY);
+    registerParameter(&shiftNodes);
+    registerParameter(&shiftNodeHandles);
+    displaceX.param_set_range(0., Geom::infinity());
+    displaceY.param_set_range(0., Geom::infinity());
+    maxSegmentSize.param_set_range(0., Geom::infinity());
+    maxSegmentSize.param_set_increments(1, 1);
+    maxSegmentSize.param_set_digits(1);
+    segments.param_set_range(1, Geom::infinity());
+    segments.param_set_increments(1, 1);
+    segments.param_set_digits(0);
+}
+
+LPERoughen::~LPERoughen() {}
+
+void LPERoughen::doBeforeEffect(SPLPEItem const */*lpeitem*/)
+{
+    displaceX.resetRandomizer();
+    displaceY.resetRandomizer();
+    srand(1);
+}
+
+Gtk::Widget *LPERoughen::newWidget()
+{
+    Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
+    vbox->set_border_width(5);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            if (param->param_key == "unit") {
+                Gtk::Label *unitLabel = Gtk::manage(new Gtk::Label(
+                                                        Glib::ustring(_("<b>Roughen unit</b>")), Gtk::ALIGN_START));
+                unitLabel->set_use_markup(true);
+                vbox->pack_start(*unitLabel, false, false, 2);
+                vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
+                                 Gtk::PACK_EXPAND_WIDGET);
+            }
+            if (param->param_key == "method") {
+                Gtk::Label *methodLabel = Gtk::manage(new Gtk::Label(
+                        Glib::ustring(_("<b>Add nodes</b> Subdivide each segment")),
+                        Gtk::ALIGN_START));
+                methodLabel->set_use_markup(true);
+                vbox->pack_start(*methodLabel, false, false, 2);
+                vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
+                                 Gtk::PACK_EXPAND_WIDGET);
+            }
+            if (param->param_key == "displaceX") {
+                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+                                                 Glib::ustring(_("<b>Jitter nodes</b> Move nodes/handles")),
+                                                 Gtk::ALIGN_START));
+                displaceXLabel->set_use_markup(true);
+                vbox->pack_start(*displaceXLabel, false, false, 2);
+                vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
+                                 Gtk::PACK_EXPAND_WIDGET);
+            }
+            Glib::ustring *tip = param->param_getTooltip();
+            if (widg) {
+                vbox->pack_start(*widg, true, true, 2);
+                if (tip) {
+                    widg->set_tooltip_text(*tip);
+                } else {
+                    widg->set_tooltip_text("");
+                    widg->set_has_tooltip(false);
+                }
+            }
+        }
+
+        ++it;
+    }
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+double LPERoughen::sign(double randNumber)
+{
+    if (rand() % 100 < 49) {
+        randNumber *= -1.;
+    }
+    return randNumber;
+}
+
+//to use when bolean operations work done
+/*
+std::vector<Geom::Path> LPERoughen::getCrackCircles(SPCurve *curve){
+    std::vector<Geom::Path> crackCircles;
+    gint seg = curve->get_segment_count()-1;
+    Piecewise<D2<SBasis> > pwd2 = paths_to_pw(curve);
+    for(type_t i = 0; i < nCracks; ++i){
+        Geom::Circle(pwd2.pointAt((rand() % (seg * 100.))/100.),crackRadius).getPath(crackCircles);
+    }
+    return crackCircles;
+}
+*/
+
+Geom::Point LPERoughen::randomize()
+{
+    double displaceXParsed = Inkscape::Util::Quantity::convert(
+                                 displaceX, unit.get_abbreviation(), "px");
+    double displaceYParsed = Inkscape::Util::Quantity::convert(
+                                 displaceY, unit.get_abbreviation(), "px");
+
+    Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed));
+    return output;
+}
+
+void LPERoughen::doEffect(SPCurve *curve)
+{
+    Geom::PathVector const original_pathv =
+        pathv_to_linear_and_cubic_beziers(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 *nCurve = new SPCurve();
+        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();
+            }
+        }
+        Geom::Point initialMove(0, 0);
+        if (shiftNodes) {
+            initialMove = randomize();
+        }
+        Geom::Point initialPoint = curve_it1->initialPoint() + initialMove;
+        nCurve->moveto(initialPoint);
+        Geom::Point A0(0, 0);
+        Geom::Point A1(0, 0);
+        Geom::Point A2(0, 0);
+        Geom::Point A3(0, 0);
+        while (curve_it1 != curve_endit) {
+            Geom::CubicBezier const *cubic = NULL;
+            A0 = curve_it1->initialPoint();
+            A1 = curve_it1->initialPoint();
+            A2 = curve_it1->finalPoint();
+            A3 = curve_it1->finalPoint();
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            if (cubic) {
+                A1 = (*cubic)[1];
+                if (shiftNodes) {
+                    A1 = (*cubic)[1] + initialMove;
+                }
+                A2 = (*cubic)[2];
+                nCurve->curveto(A1, A2, A3);
+            } else {
+                nCurve->lineto(A3);
+            }
+            double length = Inkscape::Util::Quantity::convert(
+                                curve_it1->length(0.001), "px", unit.get_abbreviation());
+            std::size_t splits = 0;
+            if (method == DM_SEGMENTS) {
+                splits = segments;
+            } else {
+                splits = ceil(length / maxSegmentSize);
+            }
+            for (unsigned int t = splits; t >= 1; t--) {
+                if (t == 1 && splits != 1) {
+                    continue;
+                }
+                const SPCurve *tmp;
+                if (splits == 1) {
+                    tmp = jitter(nCurve->last_segment());
+                } else {
+                    tmp = addNodesAndJitter(nCurve->last_segment(), 1. / t);
+                }
+                if (nCurve->get_segment_count() > 1) {
+                    nCurve->backspace();
+                    nCurve->append_continuous(tmp, 0.001);
+                } else {
+                    nCurve = tmp->copy();
+                }
+                delete tmp;
+            }
+            ++curve_it1;
+            if(curve_it2 != curve_endit) {
+                ++curve_it2;
+            }
+        }
+        if (path_it->closed()) {
+            nCurve->closepath_current();
+        }
+        curve->append(nCurve, false);
+        nCurve->reset();
+        delete nCurve;
+    }
+}
+
+SPCurve *LPERoughen::addNodesAndJitter(const Geom::Curve *A, double t)
+{
+    SPCurve *out = new SPCurve();
+    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
+    Geom::Point A1(0, 0);
+    Geom::Point A2(0, 0);
+    Geom::Point A3(0, 0);
+    Geom::Point B1(0, 0);
+    Geom::Point B2(0, 0);
+    Geom::Point B3(0, 0);
+    if (shiftNodes) {
+        A3 = randomize();
+        B3 = randomize();
+    }
+    if (shiftNodeHandles) {
+        A1 = randomize();
+        A2 = randomize();
+        B1 = randomize();
+        B2 = randomize();
+    } else {
+        A2 = A3;
+        B1 = A3;
+        B2 = B3;
+    }
+    if (cubic) {
+        std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
+        std::vector<Geom::Point> seg1 = div.first.points(),
+                                 seg2 = div.second.points();
+        out->moveto(seg1[0]);
+        out->curveto(seg1[1] + A1, seg1[2] + A2, seg1[3] + A3);
+        out->curveto(seg2[1] + B1, seg2[2], seg2[3]);
+    } else if (shiftNodeHandles) {
+        out->moveto(A->initialPoint());
+        out->curveto(A->pointAt(t / 3) + A1, A->pointAt((t / 3) * 2) + A2,
+                     A->pointAt(t) + A3);
+        out->curveto(A->pointAt(t + (t / 3)) + B1, A->pointAt(t + ((t / 3) * 2)),
+                     A->finalPoint());
+    } else {
+        out->moveto(A->initialPoint());
+        out->lineto(A->pointAt(t) + A3);
+        out->lineto(A->finalPoint());
+    }
+    return out;
+}
+
+SPCurve *LPERoughen::jitter(const Geom::Curve *A)
+{
+    SPCurve *out = new SPCurve();
+    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
+    Geom::Point A1(0, 0);
+    Geom::Point A2(0, 0);
+    Geom::Point A3(0, 0);
+    if (shiftNodes) {
+        A3 = randomize();
+    }
+    if (shiftNodeHandles) {
+        A1 = randomize();
+        A2 = randomize();
+    } else {
+        A2 = A3;
+    }
+    if (cubic) {
+        out->moveto((*cubic)[0]);
+        out->curveto((*cubic)[1] + A1, (*cubic)[2] + A2, (*cubic)[3] + A3);
+    } else if (shiftNodeHandles) {
+        out->moveto(A->initialPoint());
+        out->curveto(A->pointAt(0.3333) + A1, A->pointAt(0.6666) + A2,
+                     A->finalPoint() + A3);
+    } else {
+        out->moveto(A->initialPoint());
+        out->lineto(A->finalPoint() + A3);
+    }
+    return out;
+}
+
+Geom::Point LPERoughen::tpoint(Geom::Point A, Geom::Point B, double t)
+{
+    using Geom::X;
+    using Geom::Y;
+    return Geom::Point(A[X] + t * (B[X] - A[X]), A[Y] + t * (B[Y] - A[Y]));
+}
+
+}; //namespace LivePathEffect
+}; /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
 
=== added file 'src/live_effects/lpe-roughen.h'
--- src/live_effects/lpe-roughen.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/lpe-roughen.h	2014-09-15 15:24:25 +0000
@@ -0,0 +1,63 @@
+/** @file
+ * @brief Roughen LPE effect, see lpe-roughen.cpp.
+ */
+/* Authors:
+ *   Jabier Arraiza Cenoz <[e-mail]>
+ *
+ * Copyright (C) 2014 Authors
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#ifndef INKSCAPE_LPE_ROUGHEN_H
+#define INKSCAPE_LPE_ROUGHEN_H
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
+#include "live_effects/parameter/path.h"
+#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/unit.h"
+#include "live_effects/parameter/random.h"
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+enum DivisionMethod {
+    DM_SEGMENTS,
+    DM_SIZE,
+    DM_END
+};
+
+class LPERoughen : public Effect {
+
+public:
+    LPERoughen(LivePathEffectObject *lpeobject);
+    virtual ~LPERoughen();
+
+    virtual void doEffect(SPCurve *curve);
+    virtual double sign(double randNumber);
+    virtual Geom::Point randomize();
+    virtual void doBeforeEffect(SPLPEItem const */*lpeitem*/);
+    virtual SPCurve *addNodesAndJitter(const Geom::Curve *A, double t);
+    virtual SPCurve *jitter(const Geom::Curve *A);
+    virtual Geom::Point tpoint(Geom::Point A, Geom::Point B, double t = 0.5);
+    virtual Gtk::Widget *newWidget();
+
+private:
+    UnitParam unit;
+    EnumParam<DivisionMethod> method;
+    ScalarParam maxSegmentSize;
+    ScalarParam segments;
+    RandomParam displaceX;
+    RandomParam displaceY;
+    BoolParam shiftNodes;
+    BoolParam shiftNodeHandles;
+    LPERoughen(const LPERoughen &);
+    LPERoughen &operator=(const LPERoughen &);
+
+};
+
+}; //namespace LivePathEffect
+}; //namespace Inkscape
+#endif
 
=== modified file 'src/live_effects/parameter/Makefile_insert'
--- src/live_effects/parameter/Makefile_insert	2012-01-12 21:06:16 +0000
+++ src/live_effects/parameter/Makefile_insert	2014-09-15 15:24:25 +0000
@@ -22,6 +22,8 @@
 	live_effects/parameter/powerstrokepointarray.h	\
 	live_effects/parameter/text.cpp	\
 	live_effects/parameter/text.h	\
+	live_effects/parameter/togglebutton.cpp	\
+	live_effects/parameter/togglebutton.h	\
 	live_effects/parameter/unit.cpp	\
 	live_effects/parameter/unit.h	\
 	live_effects/parameter/vector.cpp	\
 
=== added file 'src/live_effects/parameter/togglebutton.cpp'
--- src/live_effects/parameter/togglebutton.cpp	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/togglebutton.cpp	2014-09-15 15:24:25 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) Johan Engelen 2007 <[e-mail]>
+ * Copyright (C) Jabiertxo Arraiza Cenoz 2014 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "ui/widget/registered-widget.h"
+#include "live_effects/parameter/togglebutton.h"
+#include "live_effects/effect.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "widgets/icon.h"
+#include "inkscape.h"
+#include "verbs.h"
+#include "helper-fns.h"
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+ToggleButtonParam::ToggleButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
+                      const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
+                      Effect* effect, bool default_value )
+    : Parameter(label, tip, key, wr, effect), value(default_value), defvalue(default_value)
+{
+}
+
+ToggleButtonParam::~ToggleButtonParam()
+{
+}
+
+void
+ToggleButtonParam::param_set_default()
+{
+    param_setValue(defvalue);
+}
+
+bool
+ToggleButtonParam::param_readSVGValue(const gchar * strvalue)
+{
+    param_setValue(helperfns_read_bool(strvalue, defvalue));
+    return true; // not correct: if value is unacceptable, should return false!
+}
+
+gchar *
+ToggleButtonParam::param_getSVGValue() const
+{
+    gchar * str = g_strdup(value ? "true" : "false");
+    return str;
+}
+
+Gtk::Widget *
+ToggleButtonParam::param_newWidget()
+{
+    Inkscape::UI::Widget::RegisteredToggleButton * checkwdg = Gtk::manage(
+        new Inkscape::UI::Widget::RegisteredToggleButton( param_label,
+                                                         param_tooltip,
+                                                         param_key,
+                                                         *param_wr,
+                                                         false,
+                                                         param_effect->getRepr(),
+                                                         param_effect->getSPDoc()) );
+
+    checkwdg->setActive(value);
+    checkwdg->setProgrammatically = false;
+    checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
+
+    return dynamic_cast<Gtk::Widget *> (checkwdg);
+}
+
+void
+ToggleButtonParam::param_setValue(bool newvalue)
+{
+    value = newvalue;
+}
+
+} /* namespace LivePathEffect */
+
+} /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
 
=== added file 'src/live_effects/parameter/togglebutton.h'
--- src/live_effects/parameter/togglebutton.h	1970-01-01 00:00:00 +0000
+++ src/live_effects/parameter/togglebutton.h	2014-09-15 15:24:25 +0000
@@ -0,0 +1,56 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_TOGGLEBUTTON_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_TOGGLEBUTTON_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+* Copyright (C) Johan Engelen 2007 <[e-mail]>
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <glib.h>
+
+#include "live_effects/parameter/parameter.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+
+class ToggleButtonParam : public Parameter {
+public:
+    ToggleButtonParam( const Glib::ustring& label,
+               const Glib::ustring& tip,
+               const Glib::ustring& key,
+               Inkscape::UI::Widget::Registry* wr,
+               Effect* effect,
+               bool default_value = false);
+    virtual ~ToggleButtonParam();
+
+    virtual Gtk::Widget * param_newWidget();
+
+    virtual bool param_readSVGValue(const gchar * strvalue);
+    virtual gchar * param_getSVGValue() const;
+
+    void param_setValue(bool newvalue);
+    virtual void param_set_default();
+
+    bool get_value() const { return value; };
+
+    inline operator bool() const { return value; };
+
+private:
+    ToggleButtonParam(const ToggleButtonParam&);
+    ToggleButtonParam& operator=(const ToggleButtonParam&);
+
+    bool value;
+    bool defvalue;
+};
+
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif
 
=== modified file 'src/ui/tools/node-tool.h'
--- src/ui/tools/node-tool.h	2014-08-01 14:28:31 +0000
+++ src/ui/tools/node-tool.h	2014-09-15 15:24:25 +0000
@@ -15,6 +15,9 @@
 #include <glib.h>
 #include "ui/tools/tool-base.h"
 
+// we need it to call it from Live Effect
+#include "selection.h"
+
 namespace Inkscape {
 	namespace Display {
 		class TemporaryItem;
 
=== modified file 'src/ui/widget/registered-widget.cpp'
--- src/ui/widget/registered-widget.cpp	2014-03-30 21:43:02 +0000
+++ src/ui/widget/registered-widget.cpp	2014-09-15 15:24:25 +0000
@@ -99,6 +99,59 @@
     _wr->setUpdating (false);
 }
 
+/*#########################################
+ * Registered TOGGLEBUTTON
+ */
+
+RegisteredToggleButton::~RegisteredToggleButton()
+{
+    _toggled_connection.disconnect();
+}
+
+RegisteredToggleButton::RegisteredToggleButton (const Glib::ustring& label, const Glib::ustring& tip, const Glib::ustring& key, Registry& wr, bool right, Inkscape::XML::Node* repr_in, SPDocument *doc_in, char const *active_str, char const *inactive_str)
+    : RegisteredWidget<Gtk::ToggleButton>(label)
+    , _active_str(active_str)
+    , _inactive_str(inactive_str)
+{
+    init_parent(key, wr, repr_in, doc_in);
+    setProgrammatically = false;
+    set_tooltip_text (tip);
+    set_alignment (right? 1.0 : 0.0, 0.5);
+    _toggled_connection = signal_toggled().connect (sigc::mem_fun (*this, &RegisteredToggleButton::on_toggled));
+}
+
+void
+RegisteredToggleButton::setActive (bool b)
+{
+    setProgrammatically = true;
+    set_active (b);
+    //The slave button is greyed out if the master button is untoggled
+    for (std::list<Gtk::Widget*>::const_iterator i = _slavewidgets.begin(); i != _slavewidgets.end(); ++i) {
+        (*i)->set_sensitive(b);
+    }
+    setProgrammatically = false;
+}
+
+void
+RegisteredToggleButton::on_toggled()
+{
+    if (setProgrammatically) {
+        setProgrammatically = false;
+        return;
+    }
+
+    if (_wr->isUpdating())
+        return;
+    _wr->setUpdating (true);
+
+    write_to_xml(get_active() ? _active_str : _inactive_str);
+    //The slave button is greyed out if the master button is untoggled
+    for (std::list<Gtk::Widget*>::const_iterator i = _slavewidgets.begin(); i != _slavewidgets.end(); ++i) {
+        (*i)->set_sensitive(get_active());
+    }
+
+    _wr->setUpdating (false);
+}
 
 /*#########################################
  * Registered UNITMENU
 
=== modified file 'src/ui/widget/registered-widget.h'
--- src/ui/widget/registered-widget.h	2014-03-27 01:33:44 +0000
+++ src/ui/widget/registered-widget.h	2014-09-15 15:24:25 +0000
@@ -163,6 +163,31 @@
     void on_toggled();
 };
 
+class RegisteredToggleButton : public RegisteredWidget<Gtk::ToggleButton> {
+public:
+    virtual ~RegisteredToggleButton();
+    RegisteredToggleButton (const Glib::ustring& label, const Glib::ustring& tip, const Glib::ustring& key, Registry& wr, bool right=true, Inkscape::XML::Node* repr_in=NULL, SPDocument *doc_in=NULL, char const *active_str = "true", char const *inactive_str = "false");
+
+    void setActive (bool);
+
+    std::list<Gtk::Widget*> _slavewidgets;
+
+    // a slave button is only sensitive when the master button is active
+    // i.e. a slave button is greyed-out when the master button is not checked
+
+    void setSlaveWidgets(std::list<Gtk::Widget*> btns) {
+        _slavewidgets = btns;
+    }
+
+    bool setProgrammatically; // true if the value was set by setActive, not changed by the user;
+                                // if a callback checks it, it must reset it back to false
+
+protected:
+    char const *_active_str, *_inactive_str;
+    sigc::connection  _toggled_connection;
+    void on_toggled();
+};
+
 class RegisteredUnitMenu : public RegisteredWidget<Labelled> {
 public:
     ~RegisteredUnitMenu();