Update to experimental r13428

(bzr r13090.1.89)

19 files changed, 877 insertions, 839 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index bb34047a8..282797a50 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -220,7 +220,7 @@ endif
 # someone updates the BZR working directory.
 inkscape-version.cpp: $(inkscape_version_deps)
 	VER_PREFIX="$(VERSION)";\
-	VER_BZRREV=" r`bzr revno --tree`"; \
+	VER_BZRREV=" r`bzr revno --tree $(top_srcdir)`"; \
 	if test ! -z "`bzr status -S -V $(srcdir)`"; then \
 	    VER_CUSTOM=" custom"; \
 	fi; \
diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 01621822d..179759ed6 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -131,7 +131,7 @@ const Util::EnumData<EffectType> LPETypeData[] = {
     {ROUGH_HATCHES,         N_("Hatches (rough)"),         "rough_hatches"},
     {SKETCH,                N_("Sketch"),                  "sketch"},
     {RULER,                 N_("Ruler"),                   "ruler"},
-/* 0.49 */
+/* 0.91 */
     {POWERSTROKE,           N_("Power stroke"),            "powerstroke"},
     {CLONE_ORIGINAL,        N_("Clone original path"),     "clone_original"},
     {BSPLINE,               N_("BSpline"),                 "bspline"},
@@ -147,6 +147,11 @@ const Util::EnumData<EffectType> LPETypeData[] = {
     {SIMPLIFY,               N_("Simplify"),     "simplify"},
     {LATTICE2,               N_("Lattice Deformation 2"),     "lattice2"},
     {ENVELOPE_PERSPECTIVE,  N_("Envelope-Perspective"),        "envelope-perspective"},
+    {SIMPLIFY,              N_("Simplify"),                "simplify"},
+    {LATTICE2,              N_("Lattice Deformation 2"),   "lattice2"},
+    // TRANSLATORS: "Envelope Perspective" should be equivalent to "perspective transformation"
+    {ENVELOPE_PERSPECTIVE,  N_("Envelope Perspective"),    "envelope-perspective"},
+    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),          "fillet-chamfer"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index b19b697c0..a004b8490 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -8,10 +8,13 @@
 # include <config.h>
 #endif
 
-#if WITH_GLIBMM_2_32
+#if WITH_GLIBMM_2_32 && HAVE_GLIBMM_THREADS_H
 # include <glibmm/threads.h>
 #endif
 
+#include <2geom/bezier-curve.h>
+#include <2geom/point.h>
+
 #include <gtkmm/box.h>
 #include <gtkmm/entry.h>
 #include <gtkmm/box.h>
@@ -21,10 +24,7 @@
 #include <glib.h>
 #include <glibmm/i18n.h>
 
-
 #include "display/curve.h"
-#include <2geom/bezier-curve.h>
-#include <2geom/point.h>
 #include "helper/geom-curves.h"
 #include "live_effects/lpe-bspline.h"
 #include "live_effects/lpeobject.h"
@@ -48,7 +48,8 @@
 #include "display/sp-canvas.h"
 #include <typeinfo>
 #include <vector>
-// For handling un-continuous paths:
+
+// For handling non-contiguous paths:
 #include "message-stack.h"
 #include "inkscape.h"
 #include "desktop.h"
@@ -58,320 +59,303 @@ using Inkscape::DocumentUndo;
 namespace Inkscape {
 namespace LivePathEffect {
 
-LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject)
-    : Effect(lpeobject),
-      // initialise your parameters here:
-      //testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this,
-      //Geom::Point(100,100)),
-      steps(_("Steps whith CTRL:"),
-            _("Change number of steps whith CTRL pressed"), "steps", &wr, this,
-            2),
-      ignoreCusp(_("Ignore cusp nodes:"), _("Change ignoring cusp nodes"),
-                 "ignoreCusp", &wr, this, true),
-      onlySelected(_("Change only selected nodes:"),
-                   _("Change only selected nodes"), "onlySelected", &wr, this,
-                   false),
-      weight(_("Change weight:"), _("Change weight of the effect"), "weight",
-             &wr, this, 0.3334) {
-  registerParameter(dynamic_cast<Parameter *>(&weight));
-  registerParameter(dynamic_cast<Parameter *>(&steps));
-  registerParameter(dynamic_cast<Parameter *>(&ignoreCusp));
-  registerParameter(dynamic_cast<Parameter *>(&onlySelected));
-  weight.param_set_range(0.0000, 1);
-  weight.param_set_increments(0.1, 0.1);
-  weight.param_set_digits(4);
-  steps.param_set_range(1, 10);
-  steps.param_set_increments(1, 1);
-  steps.param_set_digits(0);
+LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    steps(_("Steps whith CTRL:"), _("Change number of steps whith CTRL pressed"), "steps", &wr, this, 2),
+    ignoreCusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true),
+    onlySelected(_("Change only selected nodes"), _("Change only selected nodes"), "onlySelected", &wr, this, false),
+    weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, 0.3334)
+{
+    registerParameter(&weight);
+    registerParameter(&steps);
+    registerParameter(&ignoreCusp);
+    registerParameter(&onlySelected);
+
+    weight.param_set_range(0.0000, 1);
+    weight.param_set_increments(0.1, 0.1);
+    weight.param_set_digits(4);
+
+    steps.param_set_range(1, 10);
+    steps.param_set_increments(1, 1);
+    steps.param_set_digits(0);
 }
 
 LPEBSpline::~LPEBSpline() {}
 
-void LPEBSpline::createAndApply(const char *name, SPDocument *doc,
-                                SPItem *item) {
-  if (!SP_IS_SHAPE(item)) {
-    g_warning("LPE BSpline can only be applied to shapes (not groups).");
-  } else {
-    // Path effect definition
-    Inkscape::XML::Document *xml_doc = doc->getReprDoc();
-    Inkscape::XML::Node *repr = xml_doc->createElement("inkscape:path-effect");
-    repr->setAttribute("effect", name);
-
-    doc->getDefs()->getRepr()
-        ->addChild(repr, NULL); // adds to <defs> and assigns the 'id' attribute
-    const gchar *repr_id = repr->attribute("id");
-    Inkscape::GC::release(repr);
-
-    gchar *href = g_strdup_printf("#%s", repr_id);
-    SP_LPE_ITEM(item)->addPathEffect(href, true);
-    g_free(href);
-  }
-}
-
-void LPEBSpline::doEffect(SPCurve *curve) {
-  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();
-
-  //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
-  //penúltimo
-  for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
-       path_it != original_pathv.end(); ++path_it) {
-    //Si está vacío...
-    if (path_it->empty())
-      continue;
-    //Itreadores
-
-    Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
-    Geom::Path::const_iterator curve_it2 =
-        ++(path_it->begin());                                // outgoing curve
-    Geom::Path::const_iterator curve_endit =
-        path_it->end_default(); // this determines when the loop has to stop
-    //Creamos las lineas rectas que unen todos los puntos del trazado y donde se
-    //calcularán
-    //los puntos clave para los manejadores.
-    //Esto hace que la curva BSpline no pierda su condición aunque se trasladen
-    //dichos manejadores
-    SPCurve *nCurve = new SPCurve();
-    Geom::Point previousNode(0, 0);
-    Geom::Point node(0, 0);
-    Geom::Point pointAt1(0, 0);
-    Geom::Point pointAt2(0, 0);
-    Geom::Point nextPointAt1(0, 0);
-    Geom::Point nextPointAt2(0, 0);
-    Geom::Point nextPointAt3(0, 0);
-    Geom::D2<Geom::SBasis> SBasisIn;
-    Geom::D2<Geom::SBasis> SBasisOut;
-    Geom::D2<Geom::SBasis> SBasisHelper;
-    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();
-      }
-    }
-    //Si la curva está cerrada calculamos el punto donde
-    //deveria estar el nodo BSpline de cierre/inicio de la curva
-    //en posible caso de que se cierre con una linea recta creando un nodo
-    //BSPline
-    nCurve->moveto(curve_it1->initialPoint());
-    //Recorremos todos los segmentos menos el último
-    while (curve_it2 != curve_endit) {
-      //previousPointAt3 = pointAt3;
-      //Calculamos los puntos que dividirían en tres segmentos iguales el path
-      //recto de entrada y de salida
-      SPCurve *in = new SPCurve();
-      in->moveto(curve_it1->initialPoint());
-      in->lineto(curve_it1->finalPoint());
-      cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-      if (cubic) {
-        SBasisIn = in->first_segment()->toSBasis();
-        pointAt1 = SBasisIn.valueAt(
-            Geom::nearest_point((*cubic)[1], *in->first_segment()));
-        pointAt2 = SBasisIn.valueAt(
-            Geom::nearest_point((*cubic)[2], *in->first_segment()));
-      } else {
-        pointAt1 = in->first_segment()->initialPoint();
-        pointAt2 = in->first_segment()->finalPoint();
-      }
-      in->reset();
-      delete in;
-      //Y hacemos lo propio con el path de salida
-      //nextPointAt0 = curveOut.valueAt(0);
-      SPCurve *out = new SPCurve();
-      out->moveto(curve_it2->initialPoint());
-      out->lineto(curve_it2->finalPoint());
-      cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
-      if (cubic) {
-        SBasisOut = out->first_segment()->toSBasis();
-        nextPointAt1 = SBasisOut.valueAt(
-            Geom::nearest_point((*cubic)[1], *out->first_segment()));
-        nextPointAt2 = SBasisOut.valueAt(
-            Geom::nearest_point((*cubic)[2], *out->first_segment()));
-        ;
-        nextPointAt3 = out->first_segment()->finalPoint();
-      } else {
-        nextPointAt1 = out->first_segment()->initialPoint();
-        nextPointAt2 = out->first_segment()->finalPoint();
-        nextPointAt3 = out->first_segment()->finalPoint();
-      }
-      out->reset();
-      delete out;
-      //La curva BSpline se forma calculando el centro del segmanto de unión
-      //de el punto situado en las 2/3 partes de el segmento de entrada
-      //con el punto situado en la posición 1/3 del segmento de salida
-      //Estos dos puntos ademas estan posicionados en el lugas correspondiente
-      //de
-      //los manejadores de la curva
-      SPCurve *lineHelper = new SPCurve();
-      lineHelper->moveto(pointAt2);
-      lineHelper->lineto(nextPointAt1);
-      SBasisHelper = lineHelper->first_segment()->toSBasis();
-      lineHelper->reset();
-      delete lineHelper;
-      //almacenamos el punto del anterior bucle -o el de cierre- que nos hara de
-      //principio de curva
-      previousNode = node;
-      //Y este hará de final de curva
-      node = SBasisHelper.valueAt(0.5);
-      nCurve->curveto(pointAt1, pointAt2, node);
-      //aumentamos los valores para el siguiente paso en el bucle
-      ++curve_it1;
-      ++curve_it2;
-    }
-    SPCurve *out = new SPCurve();
-    out->moveto(curve_it1->initialPoint());
-    out->lineto(curve_it1->finalPoint());
-    cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-    if (cubic) {
-        SBasisOut = out->first_segment()->toSBasis();
-        nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment()));
-        nextPointAt2 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[2], *out->first_segment()));
-        nextPointAt3 = out->first_segment()->finalPoint();
+void LPEBSpline::createAndApply(const char *name, SPDocument *doc, SPItem *item)
+{
+    if (!SP_IS_SHAPE(item)) {
+        g_warning("LPE BSpline can only be applied to shapes (not groups).");
     } else {
-        nextPointAt1 = out->first_segment()->initialPoint();
-        nextPointAt2 = out->first_segment()->finalPoint();
-        nextPointAt3 = out->first_segment()->finalPoint();
-    }
-    out->reset();
-    delete out;
-    //Si está cerrada la curva, la cerramos sobre  el valor guardado
-    //previamente
-    //Si no finalizamos en el punto final
-    Geom::Point startNode = path_it->begin()->initialPoint();
-    if (path_it->closed()) {
-      SPCurve *start = new SPCurve();
-      start->moveto(path_it->begin()->initialPoint());
-      start->lineto(path_it->begin()->finalPoint());
-      Geom::D2<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
-      SPCurve *lineHelper = new SPCurve();
-      cubic = dynamic_cast<Geom::CubicBezier const *>(&*path_it->begin());
-      if (cubic) {
-        lineHelper->moveto(SBasisStart.valueAt(
-            Geom::nearest_point((*cubic)[1], *start->first_segment())));
-      } else {
-        lineHelper->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> SBasisEnd = end->first_segment()->toSBasis();
-      //Geom::BezierCurve const *bezier = dynamic_cast<Geom::BezierCurve
-      //const*>(&*curve_endit);
-      cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-      if (cubic) {
-        lineHelper->lineto(SBasisEnd.valueAt(
-            Geom::nearest_point((*cubic)[2], *end->first_segment())));
-      } else {
-        lineHelper->lineto(end->first_segment()->finalPoint());
-      }
-      end->reset();
-      delete end;
-      SBasisHelper = lineHelper->first_segment()->toSBasis();
-      lineHelper->reset();
-      delete lineHelper;
-      startNode = SBasisHelper.valueAt(0.5);
-      nCurve->curveto(nextPointAt1, nextPointAt2, startNode);
-      nCurve->move_endpoints(startNode, startNode);
-    } else {
-      SPCurve *start = new SPCurve();
-      start->moveto(path_it->begin()->initialPoint());
-      start->lineto(path_it->begin()->finalPoint());
-      startNode = start->first_segment()->initialPoint();
-      start->reset();
-      delete start;
-      nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);
-      nCurve->move_endpoints(startNode, nextPointAt3);
-    }
-    //y cerramos la curva
-    if (path_it->closed()) {
-      nCurve->closepath_current();
+        // Path effect definition
+        Inkscape::XML::Document *xml_doc = doc->getReprDoc();
+        Inkscape::XML::Node *repr = xml_doc->createElement("inkscape:path-effect");
+        repr->setAttribute("effect", name);
+
+        doc->getDefs()->getRepr()->addChild(repr, NULL); // adds to <defs> and assigns the 'id' attribute
+        const gchar *repr_id = repr->attribute("id");
+        Inkscape::GC::release(repr);
+
+        gchar *href = g_strdup_printf("#%s", repr_id);
+        SP_LPE_ITEM(item)->addPathEffect(href, true);
+        g_free(href);
     }
-    curve->append(nCurve, false);
-    nCurve->reset();
-    delete nCurve;
-  }
 }
 
-Gtk::Widget *LPEBSpline::newWidget() {
-  // use manage here, because after deletion of Effect object, others might
-  // still be pointing to this widget.
-  Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
-
-  vbox->set_border_width(5);
-  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 == "weight"){
-          Gtk::HBox * buttons = Gtk::manage(new Gtk::HBox(true,0));
-          Gtk::Button *defaultWeight =
-              Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight"))));
-          defaultWeight->signal_clicked()
-              .connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight), widg));
-          buttons->pack_start(*defaultWeight, true, true, 2);
-          Gtk::Button *makeCusp =
-              Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp"))));
-          makeCusp->signal_clicked()
-              .connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp), widg));
-          buttons->pack_start(*makeCusp, true, true, 2);
-          vbox->pack_start(*buttons, true, true, 2);
-      }
-      if (param->param_key == "weight" || param->param_key == "steps") {
-        Inkscape::UI::Widget::Scalar *widgRegistered =
-            Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-        widgRegistered->signal_value_changed()
-            .connect(sigc::mem_fun(*this, &LPEBSpline::toWeight));
-        widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-        if (widg){
-            Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-            std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
-            Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-            entryWidg->set_width_chars(6);
+void LPEBSpline::doEffect(SPCurve *curve)
+{
+    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();
+
+    //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
+    //penúltimo
+    for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
+            path_it != original_pathv.end(); ++path_it) {
+        //Si está vacío...
+        if (path_it->empty())
+            continue;
+        //Itreadores
+
+        Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
+        Geom::Path::const_iterator curve_it2 =
+            ++(path_it->begin());                                // outgoing curve
+        Geom::Path::const_iterator curve_endit =
+            path_it->end_default(); // this determines when the loop has to stop
+        //Creamos las lineas rectas que unen todos los puntos del trazado y donde se
+        //calcularán
+        //los puntos clave para los manejadores.
+        //Esto hace que la curva BSpline no pierda su condición aunque se trasladen
+        //dichos manejadores
+        SPCurve *nCurve = new SPCurve();
+        Geom::Point previousNode(0, 0);
+        Geom::Point node(0, 0);
+        Geom::Point pointAt1(0, 0);
+        Geom::Point pointAt2(0, 0);
+        Geom::Point nextPointAt1(0, 0);
+        Geom::Point nextPointAt2(0, 0);
+        Geom::Point nextPointAt3(0, 0);
+        Geom::D2<Geom::SBasis> SBasisIn;
+        Geom::D2<Geom::SBasis> SBasisOut;
+        Geom::D2<Geom::SBasis> SBasisHelper;
+        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();
+            }
+        }
+        //Si la curva está cerrada calculamos el punto donde
+        //deveria estar el nodo BSpline de cierre/inicio de la curva
+        //en posible caso de que se cierre con una linea recta creando un nodo
+        //BSPline
+        nCurve->moveto(curve_it1->initialPoint());
+        //Recorremos todos los segmentos menos el último
+        while (curve_it2 != curve_endit) {
+            //previousPointAt3 = pointAt3;
+            //Calculamos los puntos que dividirían en tres segmentos iguales el path
+            //recto de entrada y de salida
+            SPCurve *in = new SPCurve();
+            in->moveto(curve_it1->initialPoint());
+            in->lineto(curve_it1->finalPoint());
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            if (cubic) {
+                SBasisIn = in->first_segment()->toSBasis();
+                pointAt1 = SBasisIn.valueAt(
+                               Geom::nearest_point((*cubic)[1], *in->first_segment()));
+                pointAt2 = SBasisIn.valueAt(
+                               Geom::nearest_point((*cubic)[2], *in->first_segment()));
+            } else {
+                pointAt1 = in->first_segment()->initialPoint();
+                pointAt2 = in->first_segment()->finalPoint();
+            }
+            in->reset();
+            delete in;
+            //Y hacemos lo propio con el path de salida
+            //nextPointAt0 = curveOut.valueAt(0);
+            SPCurve *out = new SPCurve();
+            out->moveto(curve_it2->initialPoint());
+            out->lineto(curve_it2->finalPoint());
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
+            if (cubic) {
+                SBasisOut = out->first_segment()->toSBasis();
+                nextPointAt1 = SBasisOut.valueAt(
+                                   Geom::nearest_point((*cubic)[1], *out->first_segment()));
+                nextPointAt2 = SBasisOut.valueAt(
+                                   Geom::nearest_point((*cubic)[2], *out->first_segment()));
+                ;
+                nextPointAt3 = out->first_segment()->finalPoint();
+            } else {
+                nextPointAt1 = out->first_segment()->initialPoint();
+                nextPointAt2 = out->first_segment()->finalPoint();
+                nextPointAt3 = out->first_segment()->finalPoint();
+            }
+            out->reset();
+            delete out;
+            //La curva BSpline se forma calculando el centro del segmanto de unión
+            //de el punto situado en las 2/3 partes de el segmento de entrada
+            //con el punto situado en la posición 1/3 del segmento de salida
+            //Estos dos puntos ademas estan posicionados en el lugas correspondiente
+            //de
+            //los manejadores de la curva
+            SPCurve *lineHelper = new SPCurve();
+            lineHelper->moveto(pointAt2);
+            lineHelper->lineto(nextPointAt1);
+            SBasisHelper = lineHelper->first_segment()->toSBasis();
+            lineHelper->reset();
+            delete lineHelper;
+            //almacenamos el punto del anterior bucle -o el de cierre- que nos hara de
+            //principio de curva
+            previousNode = node;
+            //Y este hará de final de curva
+            node = SBasisHelper.valueAt(0.5);
+            nCurve->curveto(pointAt1, pointAt2, node);
+            //aumentamos los valores para el siguiente paso en el bucle
+            ++curve_it1;
+            ++curve_it2;
+        }
+        SPCurve *out = new SPCurve();
+        out->moveto(curve_it1->initialPoint());
+        out->lineto(curve_it1->finalPoint());
+        cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+        if (cubic) {
+            SBasisOut = out->first_segment()->toSBasis();
+            nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment()));
+            nextPointAt2 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[2], *out->first_segment()));
+            nextPointAt3 = out->first_segment()->finalPoint();
+        } else {
+            nextPointAt1 = out->first_segment()->initialPoint();
+            nextPointAt2 = out->first_segment()->finalPoint();
+            nextPointAt3 = out->first_segment()->finalPoint();
         }
-      }
-      if (param->param_key == "onlySelected") {
-        Gtk::CheckButton *widgRegistered =
-            Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-        widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-      }
-      if (param->param_key == "ignoreCusp") {
-        Gtk::CheckButton *widgRegistered =
-            Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-        widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-      }
-      Glib::ustring *tip = param->param_getTooltip();
-      if (widg) {
-        vbox->pack_start(*widg, true, true, 2);
-        if (tip) {
-          widg->set_tooltip_text(*tip);
+        out->reset();
+        delete out;
+        //Si está cerrada la curva, la cerramos sobre  el valor guardado
+        //previamente
+        //Si no finalizamos en el punto final
+        Geom::Point startNode = path_it->begin()->initialPoint();
+        if (path_it->closed()) {
+            SPCurve *start = new SPCurve();
+            start->moveto(path_it->begin()->initialPoint());
+            start->lineto(path_it->begin()->finalPoint());
+            Geom::D2<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
+            SPCurve *lineHelper = new SPCurve();
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*path_it->begin());
+            if (cubic) {
+                lineHelper->moveto(SBasisStart.valueAt(
+                                       Geom::nearest_point((*cubic)[1], *start->first_segment())));
+            } else {
+                lineHelper->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> SBasisEnd = end->first_segment()->toSBasis();
+
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            if (cubic) {
+                lineHelper->lineto(SBasisEnd.valueAt(
+                                       Geom::nearest_point((*cubic)[2], *end->first_segment())));
+            } else {
+                lineHelper->lineto(end->first_segment()->finalPoint());
+            }
+            end->reset();
+            delete end;
+            SBasisHelper = lineHelper->first_segment()->toSBasis();
+            lineHelper->reset();
+            delete lineHelper;
+            startNode = SBasisHelper.valueAt(0.5);
+            nCurve->curveto(nextPointAt1, nextPointAt2, startNode);
+            nCurve->move_endpoints(startNode, startNode);
         } else {
-          widg->set_tooltip_text("");
-          widg->set_has_tooltip(false);
+            SPCurve *start = new SPCurve();
+            start->moveto(path_it->begin()->initialPoint());
+            start->lineto(path_it->begin()->finalPoint());
+            startNode = start->first_segment()->initialPoint();
+            start->reset();
+            delete start;
+            nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);
+            nCurve->move_endpoints(startNode, nextPointAt3);
         }
-      }
+        //y cerramos la curva
+        if (path_it->closed()) {
+            nCurve->closepath_current();
+        }
+        curve->append(nCurve, false);
+        nCurve->reset();
+        delete nCurve;
     }
+}
+
+Gtk::Widget *LPEBSpline::newWidget()
+{
+    // use manage here, because after deletion of Effect object, others might
+    // still be pointing to this widget.
+    Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
+
+    vbox->set_border_width(5);
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = Gtk::manage(param->param_newWidget());
+            if (param->param_key == "weight") {
+                Gtk::HBox * buttons = Gtk::manage(new Gtk::HBox(true, 0));
+
+                Gtk::Button *defaultWeight = Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight"))));
+                defaultWeight->signal_clicked().connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight), widg));
+                buttons->pack_start(*defaultWeight, true, true, 2);
+
+                Gtk::Button *makeCusp = Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp"))));
+                makeCusp->signal_clicked().connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp), widg));
+                buttons->pack_start(*makeCusp, true, true, 2);
+
+                vbox->pack_start(*buttons, true, true, 2);
+            }
+            if (param->param_key == "weight" || param->param_key == "steps") {
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEBSpline::toWeight));
+
+                if (widg) {
+                    Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
+                    Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entryWidg->set_width_chars(6);
+                }
+            }
 
-    ++it;
-  }
-  return dynamic_cast<Gtk::Widget *>(vbox);
+            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 vbox;
 }
 
-void LPEBSpline::toDefaultWeight(Gtk::Widget *widgWeight) { 
+void LPEBSpline::toDefaultWeight(Gtk::Widget *widgWeight)
+{
     weight.param_set_value(0.3334);
     changeWeight(0.3334);
     Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widgWeight);
@@ -380,7 +364,8 @@ void LPEBSpline::toDefaultWeight(Gtk::Widget *widgWeight) {
     entryWidg->set_text("0.3334");
 }
 
-void LPEBSpline::toMakeCusp(Gtk::Widget *widgWeight) { 
+void LPEBSpline::toMakeCusp(Gtk::Widget *widgWeight)
+{
     weight.param_set_value(0.0000);
     changeWeight(0.0000);
     Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widgWeight);
@@ -389,348 +374,353 @@ void LPEBSpline::toMakeCusp(Gtk::Widget *widgWeight) {
     entryWidg->set_text("0.0000");
 }
 
-void LPEBSpline::toWeight() { changeWeight(weight); }
-
-void LPEBSpline::changeWeight(double weightValue) {
-  SPDesktop *desktop = inkscape_active_desktop();
-  Inkscape::Selection *selection = sp_desktop_selection(desktop);
-  GSList *items = (GSList *)selection->itemList();
-  SPItem *item = (SPItem *)g_slist_nth(items, 0)->data;
-  SPPath *path = SP_PATH(item);
-  SPCurve *curve = path->get_curve_for_edit();
-  LPEBSpline::doBSplineFromWidget(curve, weightValue);
-  gchar *str = sp_svg_write_path(curve->get_pathvector());
-  path->getRepr()->setAttribute("inkscape:original-d", str);
-  if (INK_IS_NODE_TOOL(desktop->event_context)) {
-    Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
-    nt->desktop->updateNow();
-  }
-  g_free(str);
-  curve->unref();
-  desktop->clearWaitingCursor();
-  DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_LPE,
-                     _("Modified the weight of the BSpline"));
+void LPEBSpline::toWeight()
+{
+    changeWeight(weight);
 }
 
-bool LPEBSpline::nodeIsSelected(Geom::Point nodePoint) {
-  using Geom::X;
-  using Geom::Y;
-
-  if (points.size() > 0) {
-    for (std::vector<Geom::Point>::iterator i = points.begin();
-         i != points.end(); ++i) {
-      Geom::Point p = *i;
-      if (Geom::are_near(p, nodePoint, 0.0001)) {
-        return true;
-      } else {
-      }
+void LPEBSpline::changeWeight(double weightValue)
+{
+    SPDesktop *desktop = inkscape_active_desktop();
+    Inkscape::Selection *selection = sp_desktop_selection(desktop);
+    GSList *items = (GSList *)selection->itemList();
+    SPItem *item = (SPItem *)g_slist_nth(items, 0)->data;
+    SPPath *path = SP_PATH(item);
+    SPCurve *curve = path->get_curve_for_edit();
+    LPEBSpline::doBSplineFromWidget(curve, weightValue);
+    gchar *str = sp_svg_write_path(curve->get_pathvector());
+    path->getRepr()->setAttribute("inkscape:original-d", str);
+    if (INK_IS_NODE_TOOL(desktop->event_context)) {
+        Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
+        nt->desktop->updateNow();
     }
-  }
-  return false;
+    g_free(str);
+    curve->unref();
+    desktop->clearWaitingCursor();
+    DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_LPE, _("Modified the weight of a BSpline"));
 }
 
-void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) {
-  using Geom::X;
-  using Geom::Y;
-  SPDesktop *desktop = inkscape_active_desktop();
-  if (INK_IS_NODE_TOOL(desktop->event_context)) {
-    Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
-    Inkscape::UI::ControlPointSelection::Set &selection =
-        nt->_selected_nodes->allPoints();
-    points.clear();
-    std::vector<Geom::Point>::iterator pbegin;
-    for (Inkscape::UI::ControlPointSelection::Set::iterator i =
-             selection.begin();
-         i != selection.end(); ++i) {
-      if ((*i)->selected()) {
-        Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
-        pbegin = points.begin();
-        points.insert(pbegin, desktop->doc2dt(n->position()));
-      }
-    }
-  }
-  //bool hasNodesSelected = LPEBspline::hasNodesSelected();
-  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();
-
-  //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
-  //penúltimo
-  for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
-       path_it != original_pathv.end(); ++path_it) {
-    //Si está vacío...
-    if (path_it->empty())
-      continue;
-    //Itreadores
-
-    Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
-    Geom::Path::const_iterator curve_it2 =
-        ++(path_it->begin());                                // outgoing curve
-    Geom::Path::const_iterator curve_endit =
-        path_it->end_default(); // this determines when the loop has to stop
-    //Creamos las lineas rectas que unen todos los puntos del trazado y donde se
-    //calcularán
-    //los puntos clave para los manejadores.
-    //Esto hace que la curva BSpline no pierda su condición aunque se trasladen
-    //dichos manejadores
-    SPCurve *nCurve = new SPCurve();
-    Geom::Point pointAt0(0, 0);
-    Geom::Point pointAt1(0, 0);
-    Geom::Point pointAt2(0, 0);
-    Geom::Point pointAt3(0, 0);
-    Geom::Point nextPointAt0(0, 0);
-    Geom::Point nextPointAt1(0, 0);
-    Geom::Point nextPointAt2(0, 0);
-    Geom::Point nextPointAt3(0, 0);
-    Geom::D2<Geom::SBasis> SBasisIn;
-    Geom::D2<Geom::SBasis> SBasisOut;
-    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();
-      }
-    }
-    //Si la curva está cerrada calculamos el punto donde
-    //deveria estar el nodo BSpline de cierre/inicio de la curva
-    //en posible caso de que se cierre con una linea recta creando un nodo
-    //BSPline
-    nCurve->moveto(curve_it1->initialPoint());
-    //Recorremos todos los segmentos menos el último
-    while (curve_it2 != curve_endit) {
-      //previousPointAt3 = pointAt3;
-      //Calculamos los puntos que dividirían en tres segmentos iguales el path
-      //recto de entrada y de salida
-      SPCurve *in = new SPCurve();
-      in->moveto(curve_it1->initialPoint());
-      in->lineto(curve_it1->finalPoint());
-      cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-      pointAt0 = in->first_segment()->initialPoint();
-      pointAt3 = in->first_segment()->finalPoint();
-      SBasisIn = in->first_segment()->toSBasis();
-      if (!onlySelected) {
-        if (cubic) {
-          if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-            pointAt1 = SBasisIn.valueAt(weightValue);
-            if (weightValue != 0.0000) {
-              pointAt1 =
-                  Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
-            }
-          } else {
-            pointAt1 = in->first_segment()->initialPoint();
-          }
-          if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-            pointAt2 = SBasisIn.valueAt(1 - weightValue);
-            if (weightValue != 0.0000) {
-              pointAt2 =
-                  Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+bool LPEBSpline::nodeIsSelected(Geom::Point nodePoint)
+{
+    using Geom::X;
+    using Geom::Y;
+
+    if (points.size() > 0) {
+        for (std::vector<Geom::Point>::iterator i = points.begin();
+                i != points.end(); ++i) {
+            Geom::Point p = *i;
+            if (Geom::are_near(p, nodePoint, 0.0001)) {
+                return true;
+            } else {
             }
-          } else {
-            pointAt2 = in->first_segment()->finalPoint();
-          }
-        } else {
-          if (!ignoreCusp && weightValue != 0.0000) {
-            pointAt1 = SBasisIn.valueAt(weightValue);
-            if (weightValue != 0.0000) {
-              pointAt1 =
-                  Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+        }
+    }
+    return false;
+}
+
+void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
+{
+    using Geom::X;
+    using Geom::Y;
+    SPDesktop *desktop = inkscape_active_desktop();
+    if (INK_IS_NODE_TOOL(desktop->event_context)) {
+        Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
+        Inkscape::UI::ControlPointSelection::Set &selection =
+            nt->_selected_nodes->allPoints();
+        points.clear();
+        std::vector<Geom::Point>::iterator pbegin;
+        for (Inkscape::UI::ControlPointSelection::Set::iterator i =
+                    selection.begin();
+                i != selection.end(); ++i) {
+            if ((*i)->selected()) {
+                Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
+                pbegin = points.begin();
+                points.insert(pbegin, desktop->doc2dt(n->position()));
             }
-            pointAt2 = SBasisIn.valueAt(1 - weightValue);
-            if (weightValue != 0.0000) {
-              pointAt2 =
-                  Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+        }
+    }
+    //bool hasNodesSelected = LPEBspline::hasNodesSelected();
+    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();
+
+    //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
+    //penúltimo
+    for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
+            path_it != original_pathv.end(); ++path_it) {
+        //Si está vacío...
+        if (path_it->empty())
+            continue;
+        //Itreadores
+
+        Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
+        Geom::Path::const_iterator curve_it2 =
+            ++(path_it->begin());                                // outgoing curve
+        Geom::Path::const_iterator curve_endit =
+            path_it->end_default(); // this determines when the loop has to stop
+        //Creamos las lineas rectas que unen todos los puntos del trazado y donde se
+        //calcularán
+        //los puntos clave para los manejadores.
+        //Esto hace que la curva BSpline no pierda su condición aunque se trasladen
+        //dichos manejadores
+        SPCurve *nCurve = new SPCurve();
+        Geom::Point pointAt0(0, 0);
+        Geom::Point pointAt1(0, 0);
+        Geom::Point pointAt2(0, 0);
+        Geom::Point pointAt3(0, 0);
+        Geom::Point nextPointAt0(0, 0);
+        Geom::Point nextPointAt1(0, 0);
+        Geom::Point nextPointAt2(0, 0);
+        Geom::Point nextPointAt3(0, 0);
+        Geom::D2<Geom::SBasis> SBasisIn;
+        Geom::D2<Geom::SBasis> SBasisOut;
+        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();
             }
-          } else {
-            pointAt1 = in->first_segment()->initialPoint();
-            pointAt2 = in->first_segment()->finalPoint();
-          }
         }
-      } else {
-        if (cubic) {
-          if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-            if (nodeIsSelected(pointAt0)) {
-              pointAt1 = SBasisIn.valueAt(weightValue);
-              if (weightValue != 0.0000) {
-                pointAt1 =
-                    Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
-              }
+        //Si la curva está cerrada calculamos el punto donde
+        //deveria estar el nodo BSpline de cierre/inicio de la curva
+        //en posible caso de que se cierre con una linea recta creando un nodo
+        //BSPline
+        nCurve->moveto(curve_it1->initialPoint());
+        //Recorremos todos los segmentos menos el último
+        while (curve_it2 != curve_endit) {
+            //previousPointAt3 = pointAt3;
+            //Calculamos los puntos que dividirían en tres segmentos iguales el path
+            //recto de entrada y de salida
+            SPCurve *in = new SPCurve();
+            in->moveto(curve_it1->initialPoint());
+            in->lineto(curve_it1->finalPoint());
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            pointAt0 = in->first_segment()->initialPoint();
+            pointAt3 = in->first_segment()->finalPoint();
+            SBasisIn = in->first_segment()->toSBasis();
+            if (!onlySelected) {
+                if (cubic) {
+                    if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
+                        pointAt1 = SBasisIn.valueAt(weightValue);
+                        if (weightValue != 0.0000) {
+                            pointAt1 =
+                                Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+                        }
+                    } else {
+                        pointAt1 = in->first_segment()->initialPoint();
+                    }
+                    if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
+                        pointAt2 = SBasisIn.valueAt(1 - weightValue);
+                        if (weightValue != 0.0000) {
+                            pointAt2 =
+                                Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+                        }
+                    } else {
+                        pointAt2 = in->first_segment()->finalPoint();
+                    }
+                } else {
+                    if (!ignoreCusp && weightValue != 0.0000) {
+                        pointAt1 = SBasisIn.valueAt(weightValue);
+                        if (weightValue != 0.0000) {
+                            pointAt1 =
+                                Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+                        }
+                        pointAt2 = SBasisIn.valueAt(1 - weightValue);
+                        if (weightValue != 0.0000) {
+                            pointAt2 =
+                                Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+                        }
+                    } else {
+                        pointAt1 = in->first_segment()->initialPoint();
+                        pointAt2 = in->first_segment()->finalPoint();
+                    }
+                }
             } else {
-              pointAt1 = (*cubic)[1];
+                if (cubic) {
+                    if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
+                        if (nodeIsSelected(pointAt0)) {
+                            pointAt1 = SBasisIn.valueAt(weightValue);
+                            if (weightValue != 0.0000) {
+                                pointAt1 =
+                                    Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+                            }
+                        } else {
+                            pointAt1 = (*cubic)[1];
+                        }
+                    } else {
+                        pointAt1 = in->first_segment()->initialPoint();
+                    }
+                    if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
+                        if (nodeIsSelected(pointAt3)) {
+                            pointAt2 = SBasisIn.valueAt(1 - weightValue);
+                            if (weightValue != 0.0000) {
+                                pointAt2 =
+                                    Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+                            }
+                        } else {
+                            pointAt2 = (*cubic)[2];
+                        }
+                    } else {
+                        pointAt2 = in->first_segment()->finalPoint();
+                    }
+                } else {
+                    if (!ignoreCusp && weightValue != 0.000) {
+                        if (nodeIsSelected(pointAt0)) {
+                            pointAt1 = SBasisIn.valueAt(weightValue);
+                            pointAt1 =
+                                Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+                        } else {
+                            pointAt1 = in->first_segment()->initialPoint();
+                        }
+                        if (nodeIsSelected(pointAt3)) {
+                            pointAt2 = SBasisIn.valueAt(weightValue);
+                            pointAt2 =
+                                Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
+                        } else {
+                            pointAt2 = in->first_segment()->finalPoint();
+                        }
+                    } else {
+                        pointAt1 = in->first_segment()->initialPoint();
+                        pointAt2 = in->first_segment()->finalPoint();
+                    }
+                }
             }
-          } else {
-            pointAt1 = in->first_segment()->initialPoint();
-          }
-          if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-            if (nodeIsSelected(pointAt3)) {
-              pointAt2 = SBasisIn.valueAt(1 - weightValue);
-              if (weightValue != 0.0000) {
-                pointAt2 =
-                    Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
-              }
+            in->reset();
+            delete in;
+            //La curva BSpline se forma calculando el centro del segmanto de unión
+            //de el punto situado en las 2/3 partes de el segmento de entrada
+            //con el punto situado en la posición 1/3 del segmento de salida
+            //Estos dos puntos ademas estan posicionados en el lugas correspondiente
+            //de
+            //los manejadores de la curva
+            nCurve->curveto(pointAt1, pointAt2, pointAt3);
+            //aumentamos los valores para el siguiente paso en el bucle
+            ++curve_it1;
+            ++curve_it2;
+        }
+        SPCurve *out = new SPCurve();
+        out->moveto(curve_it1->initialPoint());
+        out->lineto(curve_it1->finalPoint());
+        SBasisOut = out->first_segment()->toSBasis();
+        nextPointAt0 = out->first_segment()->initialPoint();
+        nextPointAt3 = out->first_segment()->finalPoint();
+        cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+        if (!onlySelected) {
+            if (cubic) {
+                if (!ignoreCusp || !Geom::are_near((*cubic)[1], nextPointAt0)) {
+                    nextPointAt1 = SBasisOut.valueAt(weightValue);
+                    if (weightValue != 0.0000) {
+                        nextPointAt1 =
+                            Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
+                    }
+                } else {
+                    nextPointAt1 = out->first_segment()->initialPoint();
+                }
+                if (!ignoreCusp || !Geom::are_near((*cubic)[2], nextPointAt3)) {
+                    nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
+                    if (weightValue != 0.0000) {
+                        nextPointAt2 =
+                            Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
+                    }
+                } else {
+                    nextPointAt2 = out->first_segment()->finalPoint();
+                }
             } else {
-              pointAt2 = (*cubic)[2];
+                if (!ignoreCusp && weightValue != 0.0000) {
+                    nextPointAt1 = SBasisOut.valueAt(weightValue);
+                    nextPointAt1 =
+                        Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
+                    nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
+                    nextPointAt2 =
+                        Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
+                } else {
+                    nextPointAt1 = out->first_segment()->initialPoint();
+                    nextPointAt2 = out->first_segment()->finalPoint();
+                }
             }
-          } else {
-            pointAt2 = in->first_segment()->finalPoint();
-          }
         } else {
-          if (!ignoreCusp && weightValue != 0.000) {
-            if (nodeIsSelected(pointAt0)) {
-              pointAt1 = SBasisIn.valueAt(weightValue);
-              pointAt1 =
-                  Geom::Point(pointAt1[X] + 0.0001, pointAt1[Y] + 0.0001);
+            if (cubic) {
+                if (!ignoreCusp || !Geom::are_near((*cubic)[1], nextPointAt0)) {
+                    if (nodeIsSelected(nextPointAt0)) {
+                        nextPointAt1 = SBasisOut.valueAt(weightValue);
+                        if (weightValue != 0.0000) {
+                            nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,
+                                                       nextPointAt1[Y] + 0.0001);
+                        }
+                    } else {
+                        nextPointAt1 = (*cubic)[1];
+                    }
+                } else {
+                    nextPointAt1 = out->first_segment()->initialPoint();
+                }
+                if (!ignoreCusp || !Geom::are_near((*cubic)[2], nextPointAt3)) {
+                    if (nodeIsSelected(nextPointAt3)) {
+                        nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
+                        if (weightValue != 0.0000) {
+                            nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,
+                                                       nextPointAt2[Y] + 0.0001);
+                        }
+                    } else {
+                        nextPointAt2 = (*cubic)[2];
+                    }
+                } else {
+                    nextPointAt2 = out->first_segment()->finalPoint();
+                }
             } else {
-              pointAt1 = in->first_segment()->initialPoint();
+                if (!ignoreCusp && weightValue != 0.0000) {
+                    if (nodeIsSelected(nextPointAt0)) {
+                        nextPointAt1 = SBasisOut.valueAt(weightValue);
+                        nextPointAt1 =
+                            Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
+                    } else {
+                        nextPointAt1 = out->first_segment()->initialPoint();
+                    }
+                    if (nodeIsSelected(nextPointAt3)) {
+                        nextPointAt2 = SBasisOut.valueAt(weightValue);
+                        nextPointAt2 =
+                            Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
+                    } else {
+                        nextPointAt2 = out->first_segment()->finalPoint();
+                    }
+                } else {
+                    nextPointAt1 = out->first_segment()->initialPoint();
+                    nextPointAt2 = out->first_segment()->finalPoint();
+                }
             }
-            if (nodeIsSelected(pointAt3)) {
-              pointAt2 = SBasisIn.valueAt(weightValue);
-              pointAt2 =
-                  Geom::Point(pointAt2[X] + 0.0001, pointAt2[Y] + 0.0001);
-            } else {
-              pointAt2 = in->first_segment()->finalPoint();
-            }
-          } else {
-            pointAt1 = in->first_segment()->initialPoint();
-            pointAt2 = in->first_segment()->finalPoint();
-          }
-        }
-      }
-      in->reset();
-      delete in;
-      //La curva BSpline se forma calculando el centro del segmanto de unión
-      //de el punto situado en las 2/3 partes de el segmento de entrada
-      //con el punto situado en la posición 1/3 del segmento de salida
-      //Estos dos puntos ademas estan posicionados en el lugas correspondiente
-      //de
-      //los manejadores de la curva
-      nCurve->curveto(pointAt1, pointAt2, pointAt3);
-      //aumentamos los valores para el siguiente paso en el bucle
-      ++curve_it1;
-      ++curve_it2;
-    }
-    SPCurve *out = new SPCurve();
-    out->moveto(curve_it1->initialPoint());
-    out->lineto(curve_it1->finalPoint());
-    SBasisOut = out->first_segment()->toSBasis();
-    nextPointAt0 = out->first_segment()->initialPoint();
-    nextPointAt3 = out->first_segment()->finalPoint();
-    cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
-    if (!onlySelected) {
-      if (cubic) {
-        if (!ignoreCusp || !Geom::are_near((*cubic)[1], nextPointAt0)) {
-          nextPointAt1 = SBasisOut.valueAt(weightValue);
-          if (weightValue != 0.0000) {
-            nextPointAt1 =
-                Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
-          }
-        } else {
-          nextPointAt1 = out->first_segment()->initialPoint();
-        }
-        if (!ignoreCusp || !Geom::are_near((*cubic)[2], nextPointAt3)) {
-          nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
-          if (weightValue != 0.0000) {
-            nextPointAt2 =
-                Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
-          }
-        } else {
-          nextPointAt2 = out->first_segment()->finalPoint();
-        }
-      } else {
-        if (!ignoreCusp && weightValue != 0.0000) {
-          nextPointAt1 = SBasisOut.valueAt(weightValue);
-          nextPointAt1 =
-              Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
-          nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
-          nextPointAt2 =
-              Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
-        } else {
-          nextPointAt1 = out->first_segment()->initialPoint();
-          nextPointAt2 = out->first_segment()->finalPoint();
-        }
-      }
-    } else {
-      if (cubic) {
-        if (!ignoreCusp || !Geom::are_near((*cubic)[1], nextPointAt0)) {
-          if (nodeIsSelected(nextPointAt0)) {
-            nextPointAt1 = SBasisOut.valueAt(weightValue);
-            if (weightValue != 0.0000) {
-              nextPointAt1 = Geom::Point(nextPointAt1[X] + 0.0001,
-                                         nextPointAt1[Y] + 0.0001);
-            }
-          } else {
-            nextPointAt1 = (*cubic)[1];
-          }
-        } else {
-          nextPointAt1 = out->first_segment()->initialPoint();
         }
-        if (!ignoreCusp || !Geom::are_near((*cubic)[2], nextPointAt3)) {
-          if (nodeIsSelected(nextPointAt3)) {
-            nextPointAt2 = SBasisOut.valueAt(1 - weightValue);
-            if (weightValue != 0.0000) {
-              nextPointAt2 = Geom::Point(nextPointAt2[X] + 0.0001,
-                                         nextPointAt2[Y] + 0.0001);
-            }
-          } else {
-            nextPointAt2 = (*cubic)[2];
-          }
+        out->reset();
+        delete out;
+        //Aberiguamos la ultima parte de la curva correspondiente al último
+        //segmento
+        //Y hacemos lo propio con el path de salida
+        //nextPointAt0 = curveOut.valueAt(0);
+        if (path_it->closed()) {
+            nCurve->curveto(nextPointAt1, nextPointAt2,
+                            path_it->begin()->initialPoint());
+            nCurve->move_endpoints(path_it->begin()->initialPoint(),
+                                   path_it->begin()->initialPoint());
         } else {
-          nextPointAt2 = out->first_segment()->finalPoint();
+            nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);
+            nCurve->move_endpoints(path_it->begin()->initialPoint(), nextPointAt3);
         }
-      } else {
-        if (!ignoreCusp && weightValue != 0.0000) {
-          if (nodeIsSelected(nextPointAt0)) {
-            nextPointAt1 = SBasisOut.valueAt(weightValue);
-            nextPointAt1 =
-                Geom::Point(nextPointAt1[X] + 0.0001, nextPointAt1[Y] + 0.0001);
-          } else {
-            nextPointAt1 = out->first_segment()->initialPoint();
-          }
-          if (nodeIsSelected(nextPointAt3)) {
-            nextPointAt2 = SBasisOut.valueAt(weightValue);
-            nextPointAt2 =
-                Geom::Point(nextPointAt2[X] + 0.0001, nextPointAt2[Y] + 0.0001);
-          } else {
-            nextPointAt2 = out->first_segment()->finalPoint();
-          }
-        } else {
-          nextPointAt1 = out->first_segment()->initialPoint();
-          nextPointAt2 = out->first_segment()->finalPoint();
+        //y cerramos la curva
+        if (path_it->closed()) {
+            nCurve->closepath_current();
         }
-      }
-    }
-    out->reset();
-    delete out;
-    //Aberiguamos la ultima parte de la curva correspondiente al último
-    //segmento
-    //Y hacemos lo propio con el path de salida
-    //nextPointAt0 = curveOut.valueAt(0);
-    if (path_it->closed()) {
-      nCurve->curveto(nextPointAt1, nextPointAt2,
-                      path_it->begin()->initialPoint());
-      nCurve->move_endpoints(path_it->begin()->initialPoint(),
-                             path_it->begin()->initialPoint());
-    } else {
-      nCurve->curveto(nextPointAt1, nextPointAt2, nextPointAt3);
-      nCurve->move_endpoints(path_it->begin()->initialPoint(), nextPointAt3);
-    }
-    //y cerramos la curva
-    if (path_it->closed()) {
-      nCurve->closepath_current();
+        curve->append(nCurve, false);
+        nCurve->reset();
+        delete nCurve;
     }
-    curve->append(nCurve, false);
-    nCurve->reset();
-    delete nCurve;
-  }
 }
 
 }; //namespace LivePathEffect
diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h
index aff4ce812..f37741a4a 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -15,44 +15,40 @@ namespace Inkscape {
 namespace LivePathEffect {
 
 class LPEBSpline : public Effect {
-
 public:
-  LPEBSpline(LivePathEffectObject *lpeobject);
-  virtual ~LPEBSpline();
-
-  virtual void createAndApply(const char *name, SPDocument *doc, SPItem *item);
-
-  virtual LPEPathFlashType pathFlashType() const { return SUPPRESS_FLASH; }
-
-  virtual void doEffect(SPCurve *curve);
-
-  virtual void doBSplineFromWidget(SPCurve *curve, double value);
-
-  virtual bool nodeIsSelected(Geom::Point nodePoint);
-
-  virtual Gtk::Widget *newWidget();
+    LPEBSpline(LivePathEffectObject *lpeobject);
+    virtual ~LPEBSpline();
 
-  virtual void changeWeight(double weightValue);
+    virtual void createAndApply(const char *name, SPDocument *doc, SPItem *item);
+    virtual LPEPathFlashType pathFlashType() const {
+        return SUPPRESS_FLASH;
+    }
+    virtual void doEffect(SPCurve *curve);
 
-  virtual void toDefaultWeight(Gtk::Widget *widgWeight);
+    void doBSplineFromWidget(SPCurve *curve, double value);
+    bool nodeIsSelected(Geom::Point nodePoint);
 
-  virtual void toMakeCusp(Gtk::Widget *widgWeight);
+    virtual Gtk::Widget *newWidget();
 
-  virtual void toWeight();
+    void changeWeight(double weightValue);
+    void toDefaultWeight(Gtk::Widget *widgWeight);
+    void toMakeCusp(Gtk::Widget *widgWeight);
+    void toWeight();
 
-  ScalarParam steps;
+    // TODO make this private
+    ScalarParam steps;
 
 private:
-  std::vector<Geom::Point> points;
-  BoolParam ignoreCusp;
-  BoolParam onlySelected;
-  ScalarParam weight;
+    std::vector<Geom::Point> points;
+    BoolParam ignoreCusp;
+    BoolParam onlySelected;
+    ScalarParam weight;
 
-  LPEBSpline(const LPEBSpline &);
-  LPEBSpline &operator=(const LPEBSpline &);
+    LPEBSpline(const LPEBSpline &);
+    LPEBSpline &operator=(const LPEBSpline &);
 
 };
 
-}; //namespace LivePathEffect
-}; //namespace Inkscape
+} //namespace LivePathEffect
+} //namespace Inkscape
 #endif
diff --git a/src/live_effects/lpe-envelope-perspective.cpp b/src/live_effects/lpe-envelope-perspective.cpp
index bfd6e56d7..02cb67db3 100644
--- a/src/live_effects/lpe-envelope-perspective.cpp
+++ b/src/live_effects/lpe-envelope-perspective.cpp
@@ -29,17 +29,29 @@ using namespace Geom;
 namespace Inkscape {
 namespace LivePathEffect {
 
+enum DeformationType {
+  DEFORMATION_ENVELOPE,
+  DEFORMATION_PERSPECTIVE
+};
+
+static const Util::EnumData<unsigned> DeformationTypeData[] = {
+    {DEFORMATION_ENVELOPE          , N_("Envelope deformation"), "Envelope deformation"},
+    {DEFORMATION_PERSPECTIVE          , N_("Perspective"), "Perspective"}
+};
+
+static const Util::EnumDataConverter<unsigned> DeformationTypeConverter(DeformationTypeData, sizeof(DeformationTypeData)/sizeof(*DeformationTypeData));
+
 LPEEnvelopePerspective::LPEEnvelopePerspective(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     // initialise your parameters here:
-    perspective(_("Perspective"), _("Perspective"), "Perspective", &wr, this, false),
-    Up_Left_Point(_("Top Left:"), _("Top Left - Ctrl+Alt+Click to reset"), "Up_Left_Point", &wr, this),
-    Up_Right_Point(_("Top Right:"), _("Top Right - Ctrl+Alt+Click to reset"), "Up_Right_Point", &wr, this),
-    Down_Left_Point(_("Down Left:"), _("Down Left - Ctrl+Alt+Click to reset"), "Down_Left_Point", &wr, this),
-    Down_Right_Point(_("Down Right:"), _("Down Right - Ctrl+Alt+Click to reset"), "Down_Right_Point", &wr, this)
+    deform_type(_("Type"), _("Select the type of deformation"), "deform_type", DeformationTypeConverter, &wr, this, DEFORMATION_ENVELOPE),
+    Up_Left_Point(_("Top Left"), _("Top Left - Ctrl+Alt+Click to reset"), "Up_Left_Point", &wr, this),
+    Up_Right_Point(_("Top Right"), _("Top Right - Ctrl+Alt+Click to reset"), "Up_Right_Point", &wr, this),
+    Down_Left_Point(_("Down Left"), _("Down Left - Ctrl+Alt+Click to reset"), "Down_Left_Point", &wr, this),
+    Down_Right_Point(_("Down Right"), _("Down Right - Ctrl+Alt+Click to reset"), "Down_Right_Point", &wr, this)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&perspective));
+    registerParameter( dynamic_cast<Parameter *>(&deform_type));
     registerParameter( dynamic_cast<Parameter *>(&Up_Left_Point) );
     registerParameter( dynamic_cast<Parameter *>(&Up_Right_Point) );
     registerParameter( dynamic_cast<Parameter *>(&Down_Left_Point) );
@@ -54,7 +66,7 @@ void LPEEnvelopePerspective::doEffect(SPCurve *curve) {
     using Geom::X;
     using Geom::Y;
     double projmatrix[3][3];
-    if(perspective){
+    if(deform_type == DEFORMATION_PERSPECTIVE){
         std::vector<Geom::Point> handles(4);
         handles[0] = Down_Left_Point;
         handles[1] = Up_Left_Point;
@@ -144,7 +156,7 @@ void LPEEnvelopePerspective::doEffect(SPCurve *curve) {
             curve_endit = path_it->end_open();
           }
         }
-        if(perspective){
+        if(deform_type == DEFORMATION_PERSPECTIVE){
             nCurve->moveto(project_point(curve_it1->initialPoint(),projmatrix));
         }else{
             nCurve->moveto(project_point(curve_it1->initialPoint()));
@@ -159,7 +171,7 @@ void LPEEnvelopePerspective::doEffect(SPCurve *curve) {
             pointAt2 = curve_it1->finalPoint();
           }
           pointAt3 = curve_it1->finalPoint();
-          if(perspective){
+          if(deform_type == DEFORMATION_PERSPECTIVE){
             pointAt1 = project_point(pointAt1,projmatrix);
             pointAt2 = project_point(pointAt2,projmatrix);
             pointAt3 = project_point(pointAt3,projmatrix);
@@ -181,7 +193,7 @@ void LPEEnvelopePerspective::doEffect(SPCurve *curve) {
             pointAt2 = curve_it1->finalPoint();
         }
         pointAt3 = curve_it1->finalPoint();
-        if(perspective){
+        if(deform_type == DEFORMATION_PERSPECTIVE){
             pointAt1 = project_point(pointAt1,projmatrix);
             pointAt2 = project_point(pointAt2,projmatrix);
             pointAt3 = project_point(pointAt3,projmatrix);
@@ -191,7 +203,7 @@ void LPEEnvelopePerspective::doEffect(SPCurve *curve) {
             pointAt3 = project_point(pointAt3);
         }
         nCurve->curveto(pointAt1, pointAt2, pointAt3);
-        if(perspective){
+        if(deform_type == DEFORMATION_PERSPECTIVE){
             nCurve->move_endpoints(project_point(path_it->begin()->initialPoint(),projmatrix), pointAt3);
         }else{
             nCurve->move_endpoints(project_point(path_it->begin()->initialPoint()), pointAt3);
@@ -251,13 +263,6 @@ LPEEnvelopePerspective::newWidget()
     vbox->set_border_width(5);
     vbox->set_homogeneous(false);
     vbox->set_spacing(6);
-    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
-
-    Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR));
-    resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPEEnvelopePerspective::resetGrid));
-    resetButton->set_size_request(140,45);
-    vbox->pack_start(*hbox, true,true,2);
-    hbox->pack_start(*resetButton, false, false,2);
     std::vector<Parameter *>::iterator it = param_vector.begin();
     Gtk::HBox * hboxUpHandles = Gtk::manage(new Gtk::HBox(false,0));
     Gtk::HBox * hboxDownHandles = Gtk::manage(new Gtk::HBox(false,0));
@@ -319,6 +324,12 @@ LPEEnvelopePerspective::newWidget()
     hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET);
     vbox->pack_start(*hboxMiddle, false, true, 2);
     vbox->pack_start(*hboxDownHandles, true, true, 2);
+    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
+    Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR));
+    resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPEEnvelopePerspective::resetGrid));
+    resetButton->set_size_request(140,45);
+    vbox->pack_start(*hbox, true,true,2);
+    hbox->pack_start(*resetButton, false, false,2);
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -411,4 +422,4 @@ LPEEnvelopePerspective::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::v
   fill-column:99
   End:
 */
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
+// vim: file_type=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/lpe-envelope-perspective.h b/src/live_effects/lpe-envelope-perspective.h
index 6aae33936..0de9a0e35 100644
--- a/src/live_effects/lpe-envelope-perspective.h
+++ b/src/live_effects/lpe-envelope-perspective.h
@@ -60,7 +60,7 @@ protected:
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
 private:
 
-    BoolParam perspective;
+    EnumParam<unsigned> deform_type;
     PointReseteableParam Up_Left_Point;
     PointReseteableParam Up_Right_Point;
     PointReseteableParam Down_Left_Point;
diff --git a/src/live_effects/lpe-fillet-chamfer.cpp b/src/live_effects/lpe-fillet-chamfer.cpp
index 1fb68020d..a24f5e60e 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -1,36 +1,39 @@
 /*
- * Copyright (C) Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ * Author(s):
+ *   Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
  * Special thanks to Johan Engelen for the base of the effect -powerstroke-
  * Also to ScislaC for point me to the idea
  * Also su_v for his construvtive feedback and time
  * Also to Mc- (IRC nick) for his important contribution to find real time
  * values based on
- * and finaly to Liam P. White for his big help on coding, that save me a lot of
- * hours
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
+ *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
 #include "live_effects/lpe-fillet-chamfer.h"
-#include <glibmm/i18n.h>
-#include "style.h"
-#include "live_effects/parameter/filletchamferpointarray.h"
-//for update knot
+ 
+#include <2geom/sbasis-to-bezier.h>
 #include <2geom/svg-elliptical-arc.h>
 #include <2geom/line.h>
+
+#include "desktop.h"
+#include "display/curve.h"
+#include "helper/geom-nodetype.h"
+#include "live_effects/parameter/filletchamferpointarray.h"
+
+// for programmatically updating knots
 #include "selection.h"
+#include "tools-switch.h"
 #include "ui/tool/control-point-selection.h"
 #include "ui/tool/selectable-control-point.h"
-#include <2geom/sbasis-to-bezier.h>
 #include "ui/tool/node.h"
-// FIXME: The following are only needed to convert the path's SPCurve* to pwd2.
-//        There must be a more convenient way to achieve this.
-#include "display/curve.h"
-#include "helper/geom-nodetype.h"
-#include "desktop.h"
 #include "ui/tools/node-tool.h"
-#include <iostream>
-#include <tools-switch.h>
-#include <cmath>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using namespace Geom;
 namespace Inkscape {
@@ -39,34 +42,26 @@ namespace LivePathEffect {
 const double tolerance = 0.001;
 const double gapHelper = 0.00001;
 
-LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject)
-    : Effect(lpeobject),
-      fillet_chamfer_values(_("Fillet point"), _("Fillet point"),
-                            "fillet_chamfer_values", &wr, this),
-      hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this,
-                 false),
-      ignore_radius_0(_("Ignore 0 radius knots"), _("Ignore 0 radius knots"),
-                      "ignore_radius_0", &wr, this, false),
-      only_selected(_("Change only selected nodes"),
-                    _("Change only selected nodes"), "only_selected", &wr, this,
-                    false),
-      flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"),
-               "flexible", &wr, this, false),
-      unit(_("Unit"), _("Unit"), "unit", &wr, this),
-      radius(_("Radius (unit or %)"), _("Radius, in unit or %"), "radius", &wr,
-             this, 0.),
-      helper_size(_("Helper size with direction"),
-                  _("Helper size with direction"), "helper_size", &wr, this,
-                  0)
+LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    fillet_chamfer_values(_("Fillet point"), _("Fillet point"), "fillet_chamfer_values", &wr, this),
+    hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this, false),
+    ignore_radius_0(_("Ignore 0 radius knots"), _("Ignore 0 radius knots"), "ignore_radius_0", &wr, this, false),
+    only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
+    flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"), "flexible", &wr, this, false),
+    unit(_("Unit"), _("Unit"), "unit", &wr, this),
+    radius(_("Radius (unit or %)"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
+    helper_size(_("Helper size with direction"), _("Helper size with direction"), "helper_size", &wr, this, 0)
 {
-    registerParameter(dynamic_cast<Parameter *>(&fillet_chamfer_values));
-    registerParameter(dynamic_cast<Parameter *>(&unit));
-    registerParameter(dynamic_cast<Parameter *>(&radius));
-    registerParameter(dynamic_cast<Parameter *>(&helper_size));
-    registerParameter(dynamic_cast<Parameter *>(&flexible));
-    registerParameter(dynamic_cast<Parameter *>(&ignore_radius_0));
-    registerParameter(dynamic_cast<Parameter *>(&only_selected));
-    registerParameter(dynamic_cast<Parameter *>(&hide_knots));
+    registerParameter(&fillet_chamfer_values);
+    registerParameter(&unit);
+    registerParameter(&radius);
+    registerParameter(&helper_size);
+    registerParameter(&flexible);
+    registerParameter(&ignore_radius_0);
+    registerParameter(&only_selected);
+    registerParameter(&hide_knots);
+
     radius.param_set_range(0., infinity());
     radius.param_set_increments(1, 1);
     radius.param_set_digits(4);
@@ -90,53 +85,32 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
     while (it != param_vector.end()) {
         if ((*it)->widget_is_visible) {
             Parameter *param = *it;
-            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            Gtk::Widget *widg = param->param_newWidget();
             if (param->param_key == "radius") {
-                Inkscape::UI::Widget::Scalar *widgRegistered =
-                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed()
-                    .connect(sigc::mem_fun(*this, &LPEFilletChamfer::updateFillet));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::updateFillet));
+                widg = widgRegistered;
                 if (widg) {
                     Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
-                    std::vector<Gtk::Widget *> childList =
-                        scalarParameter->get_children();
+                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
                     Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
                     entryWidg->set_width_chars(6);
                 }
+            } else if (param->param_key == "flexible") {
+                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
+                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
+            } else if (param->param_key == "helper_size") {
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
+            } else if (param->param_key == "hide_knots") {
+                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
+                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleHide));
+            } else if (param->param_key == "only_selected") {
+                Gtk::manage(widg);
+            } else if (param->param_key == "ignore_radius_0") {
+                Gtk::manage(widg);
             }
-            if (param->param_key == "flexible") {
-                Gtk::CheckButton *widgRegistered =
-                    Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widgRegistered->signal_clicked()
-                    .connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-            }
-            if (param->param_key == "helper_size") {
-                Inkscape::UI::Widget::Scalar *widgRegistered =
-                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
-                widgRegistered->signal_value_changed()
-                    .connect(sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-
-            }
-            if (param->param_key == "hide_knots") {
-                Gtk::CheckButton *widgRegistered =
-                    Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widgRegistered->signal_clicked()
-                    .connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleHide));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-            }
-            if (param->param_key == "only_selected") {
-                Gtk::CheckButton *widgRegistered =
-                    Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-            }
-            if (param->param_key == "ignore_radius_0") {
-                Gtk::CheckButton *widgRegistered =
-                    Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
-                widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
-            }
+
             Glib::ustring *tip = param->param_getTooltip();
             if (widg) {
                 vbox->pack_start(*widg, true, true, 2);
@@ -153,32 +127,27 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
     }
 
     Gtk::HBox *filletButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
-    Gtk::Button *fillet =
-        Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
-    fillet->signal_clicked()
-        .connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
+    Gtk::Button *fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
+    fillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
+
     filletButtonsContainer->pack_start(*fillet, true, true, 2);
-    Gtk::Button *inverse =
-        Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
-    inverse->signal_clicked()
-        .connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverse));
+    Gtk::Button *inverse = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
+    inverse->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverse));
     filletButtonsContainer->pack_start(*inverse, true, true, 2);
 
     Gtk::HBox *chamferButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
-    Gtk::Button *chamfer =
-        Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
-    chamfer->signal_clicked()
-        .connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
+    Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
+    chamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
+
     chamferButtonsContainer->pack_start(*chamfer, true, true, 2);
-    Gtk::Button *doubleChamfer =
-        Gtk::manage(new Gtk::Button(Glib::ustring(_("Double chamfer"))));
-    doubleChamfer->signal_clicked()
-        .connect(sigc::mem_fun(*this, &LPEFilletChamfer::doubleChamfer));
+    Gtk::Button *doubleChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Double chamfer"))));
+    doubleChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::doubleChamfer));
     chamferButtonsContainer->pack_start(*doubleChamfer, true, true, 2);
+
     vbox->pack_start(*filletButtonsContainer, true, true, 2);
     vbox->pack_start(*chamferButtonsContainer, true, true, 2);
 
-    return dynamic_cast<Gtk::Widget *>(vbox);
+    return vbox;
 }
 
 void LPEFilletChamfer::toggleHide()
@@ -227,8 +196,7 @@ void LPEFilletChamfer::updateFillet()
 {
     double power = 0;
     if (!flexible) {
-        power = Inkscape::Util::Quantity::convert(radius, unit.get_abbreviation(),
-                "px") * -1;
+        power = Inkscape::Util::Quantity::convert(radius, unit.get_abbreviation(), "px") * -1;
     } else {
         power = radius;
     }
@@ -271,8 +239,7 @@ void LPEFilletChamfer::refreshKnots()
     }
 }
 
-bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint,
-                                      std::vector<Geom::Point> point)
+bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> point)
 {
     if (point.size() > 0) {
         for (std::vector<Geom::Point>::iterator i = point.begin(); i != point.end();
@@ -285,20 +252,15 @@ bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint,
     }
     return false;
 }
-void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> original_pathv,
-                                      double power)
+void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power)
 {
     std::vector<Geom::Point> point;
     SPDesktop *desktop = inkscape_active_desktop();
     if (INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nodeTool =
-            INK_NODE_TOOL(desktop->event_context);
-        Inkscape::UI::ControlPointSelection::Set &selection =
-            nodeTool->_selected_nodes->allPoints();
+        Inkscape::UI::Tools::NodeTool *nodeTool = INK_NODE_TOOL(desktop->event_context);
+        Inkscape::UI::ControlPointSelection::Set &selection = nodeTool->_selected_nodes->allPoints();
         std::vector<Geom::Point>::iterator pBegin;
-        for (Inkscape::UI::ControlPointSelection::Set::iterator i =
-                    selection.begin();
-                i != selection.end(); ++i) {
+        for (Inkscape::UI::ControlPointSelection::Set::iterator i = selection.begin(); i != selection.end(); ++i) {
             if ((*i)->selected()) {
                 Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
                 pBegin = point.begin();
@@ -350,8 +312,7 @@ void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> original_pathv,
     fillet_chamfer_values.param_set_and_write_new_value(result);
 }
 
-void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> original_pathv,
-                                    int type)
+void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> const& original_pathv, int type)
 {
     std::vector<Geom::Point> point;
     SPDesktop *desktop = inkscape_active_desktop();
@@ -374,8 +335,7 @@ void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> original_pathv,
     std::vector<Point> filletChamferData = fillet_chamfer_values.data();
     std::vector<Geom::Point> result;
     int counter = 0;
-    for (PathVector::const_iterator path_it = original_pathv.begin();
-            path_it != original_pathv.end(); ++path_it) {
+    for (PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
         int pathCounter = 0;
         if (path_it->empty())
             continue;
@@ -418,11 +378,9 @@ void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
 {
     if (SP_IS_SHAPE(lpeItem)) {
         std::vector<Point> point;
-        PathVector const &original_pathv =
-            SP_SHAPE(lpeItem)->_curve->get_pathvector();
+        PathVector const &original_pathv = SP_SHAPE(lpeItem)->_curve->get_pathvector();
         Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
-        for (PathVector::const_iterator path_it = original_pathv.begin();
-                path_it != original_pathv.end(); ++path_it) {
+        for (PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
             if (path_it->empty())
                 continue;
 
@@ -476,9 +434,7 @@ void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
     if (SP_IS_SHAPE(lpeItem)) {
         fillet_chamfer_values.set_helper_size(helper_size);
         fillet_chamfer_values.set_unit(unit.get_abbreviation());
-        SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)
-                     ->get_original_curve()
-                     : SP_SHAPE(lpeItem)->getCurve();
+        SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)->get_original_curve() : SP_SHAPE(lpeItem)->getCurve();
         std::vector<Point> filletChamferData = fillet_chamfer_values.data();
         if (!filletChamferData.empty() && getKnotsNumber(c) != (int)
                 filletChamferData.size()) {
diff --git a/src/live_effects/lpe-fillet-chamfer.h b/src/live_effects/lpe-fillet-chamfer.h
index f5eee0205..420425650 100644
--- a/src/live_effects/lpe-fillet-chamfer.h
+++ b/src/live_effects/lpe-fillet-chamfer.h
@@ -2,50 +2,57 @@
 #define INKSCAPE_LPE_FILLET_CHAMFER_H
 
 /*
- * Inkscape::LPEFilletChamfer
- * Copyright (C) Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ * Author(s):
+ *     Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
  * Special thanks to Johan Engelen for the base of the effect -powerstroke-
  * Also to ScislaC for point me to the idea
  * Also su_v for his construvtive feedback and time
- * and finaly to Liam P. White for his big help on coding, that save me a lot of
- * hours
+ * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
+ *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
+
+#include <glibmm/threads.h>
+
 #include "live_effects/parameter/enum.h"
-#include "live_effects/parameter/unit.h"
-#include "live_effects/effect.h"
 #include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/unit.h"
+
 #include "live_effects/parameter/filletchamferpointarray.h"
+#include "live_effects/effect.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
 
-class LPEFilletChamfer : public Effect {
 
+class LPEFilletChamfer : public Effect {
 public:
     LPEFilletChamfer(LivePathEffectObject *lpeobject);
     virtual ~LPEFilletChamfer();
 
-    std::vector<Geom::Path> doEffect_path(std::vector<Geom::Path> const &path_in);
+    virtual std::vector<Geom::Path> doEffect_path(std::vector<Geom::Path> const &path_in);
 
     virtual void doOnApply(SPLPEItem const *lpeItem);
     virtual void doBeforeEffect(SPLPEItem const *lpeItem);
-    virtual int getKnotsNumber(SPCurve const *c);
     virtual void adjustForNewPath(std::vector<Geom::Path> const &path_in);
-    virtual void toggleHide();
-    virtual void toggleFlexFixed();
-    virtual void chamfer();
-    virtual void fillet();
-    virtual void doubleChamfer();
-    virtual void inverse();
-    virtual void updateFillet();
-    virtual void doUpdateFillet(std::vector<Geom::Path> original_pathv,
-                                double power);
-    virtual void doChangeType(std::vector<Geom::Path> original_pathv, int type);
-    virtual bool nodeIsSelected(Geom::Point nodePoint,
-                                std::vector<Geom::Point> points);
-    virtual void refreshKnots();
-    virtual Gtk::Widget *newWidget();
+    virtual Gtk::Widget* newWidget();
+
+    int getKnotsNumber(SPCurve const *c);
+    void toggleHide();
+    void toggleFlexFixed();
+    void chamfer();
+    void fillet();
+    void doubleChamfer();
+    void inverse();
+    void updateFillet();
+    void doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power);
+    void doChangeType(std::vector<Geom::Path> const& original_pathv, int type);
+    bool nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> points);
+    void refreshKnots();
+
     FilletChamferPointArrayParam fillet_chamfer_values;
 
 private:
@@ -63,6 +70,18 @@ private:
 
 };
 
-}; //namespace LivePathEffect
-}; //namespace Inkscape
+} //namespace LivePathEffect
+} //namespace Inkscape
+
 #endif
+
+/*
+  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 :
diff --git a/src/live_effects/parameter/bool.h b/src/live_effects/parameter/bool.h
index fafb1beca..b45eeb0b3 100644
--- a/src/live_effects/parameter/bool.h
+++ b/src/live_effects/parameter/bool.h
@@ -4,7 +4,7 @@
 /*
  * Inkscape::LivePathEffectParameters
  *
-* Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
diff --git a/src/live_effects/parameter/filletchamferpointarray.cpp b/src/live_effects/parameter/filletchamferpointarray.cpp
index 5eb87aad5..33096819c 100644
--- a/src/live_effects/parameter/filletchamferpointarray.cpp
+++ b/src/live_effects/parameter/filletchamferpointarray.cpp
@@ -27,8 +27,10 @@
 #include "live_effects/lpeobject.h"
 #include "helper/geom-nodetype.h"
 #include "helper/geom-curves.h"
-#include <cmath>
 #include "ui/tools/node-tool.h"
+
+// TODO due to internal breakage in glibmm headers,
+// this has to be included last.
 #include <glibmm/i18n.h>
 
 using namespace Geom;
diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index a5de2169e..7732eee76 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -43,6 +43,15 @@ Parameter::param_write_to_repr(const char * svgd)
     param_effect->getRepr()->setAttribute(param_key.c_str(), svgd);
 }
 
+
+// In gtk2, this wasn't an issue; we could toss around
+// G_MAXDOUBLE and not worry about size allocations. But
+// in gtk3, it is an issue: it allocates widget size for the maxmium
+// value you pass to it, leading to some insane lengths.
+// If you need this to be more, please be conservative about it.
+const double SCALARPARAM_G_MAXDOUBLE = 10000000000;
+
+
 /*###########################################
  *   REAL PARAM
  */
@@ -51,8 +60,8 @@ ScalarParam::ScalarParam( const Glib::ustring& label, const Glib::ustring& tip,
                       Effect* effect, gdouble default_value)
     : Parameter(label, tip, key, wr, effect),
       value(default_value),
-      min(-G_MAXDOUBLE),
-      max(G_MAXDOUBLE),
+      min(-SCALARPARAM_G_MAXDOUBLE),
+      max(SCALARPARAM_G_MAXDOUBLE),
       integer(false),
       defvalue(default_value),
       digits(2),
@@ -108,8 +117,22 @@ ScalarParam::param_set_value(gdouble val)
 void
 ScalarParam::param_set_range(gdouble min, gdouble max)
 {
-    this->min = min;
-    this->max = max;
+    // if you look at client code, you'll see that many effects
+    // has a tendency to set an upper range of Geom::infinity().
+    // Once again, in gtk2, this is not a problem. But in gtk3,
+    // widgets get allocated the amount of size they ask for,
+    // leading to excessively long widgets.
+
+    if (min >= -SCALARPARAM_G_MAXDOUBLE) {
+        this->min = min;
+    } else {
+        this->min = -SCALARPARAM_G_MAXDOUBLE;
+    }
+    if (max <= SCALARPARAM_G_MAXDOUBLE) {
+        this->max = max;
+    } else {
+	this->max = SCALARPARAM_G_MAXDOUBLE;
+    }
 
     param_set_value(value); // reset value to see whether it is in ranges
 }
diff --git a/src/live_effects/parameter/powerstrokepointarray.cpp b/src/live_effects/parameter/powerstrokepointarray.cpp
index 4ed8998fa..427be8065 100644
--- a/src/live_effects/parameter/powerstrokepointarray.cpp
+++ b/src/live_effects/parameter/powerstrokepointarray.cpp
@@ -194,7 +194,10 @@ PowerStrokePointArrayParamKnotHolderEntity::knot_get() const
     Piecewise<D2<SBasis> > const & n = _pparam->get_pwd2_normal();
 
     Point offset_point = _pparam->_vector.at(_index);
-
+    if (offset_point[X] > pwd2.size() || offset_point[X] < 0) {
+        g_warning("Broken powerstroke point at %f, I won't try to add that", offset_point[X]);
+        return Geom::Point(infinity(), infinity());
+    }
     Point canvas_point = pwd2.valueAt(offset_point[X]) + offset_point[Y] * n.valueAt(offset_point[X]);
     return canvas_point;
 }
diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp
index 03238f935..d447afa6f 100644
--- a/src/live_effects/parameter/togglebutton.cpp
+++ b/src/live_effects/parameter/togglebutton.cpp
@@ -29,6 +29,9 @@ ToggleButtonParam::ToggleButtonParam( const Glib::ustring& label, const Glib::us
 
 ToggleButtonParam::~ToggleButtonParam()
 {
+    if (_toggled_connection.connected()) {
+        _toggled_connection.disconnect();
+    }
 }
 
 void
@@ -54,6 +57,10 @@ ToggleButtonParam::param_getSVGValue() const
 Gtk::Widget *
 ToggleButtonParam::param_newWidget()
 {
+    if (_toggled_connection.connected()) {
+        _toggled_connection.disconnect();
+    }
+
     Inkscape::UI::Widget::RegisteredToggleButton * checkwdg = Gtk::manage(
         new Inkscape::UI::Widget::RegisteredToggleButton( param_label,
                                                          param_tooltip,
@@ -65,9 +72,12 @@ ToggleButtonParam::param_newWidget()
 
     checkwdg->setActive(value);
     checkwdg->setProgrammatically = false;
-    checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
+    // TRANSLATORS: "toggle" is a verb here
+    checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Toggle path effect parameter"));
+
+    _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
 
-    return dynamic_cast<Gtk::Widget *> (checkwdg);
+    return checkwdg;
 }
 
 void
@@ -76,6 +86,11 @@ ToggleButtonParam::param_setValue(bool newvalue)
     value = newvalue;
 }
 
+void
+ToggleButtonParam::toggled() {
+    _signal_toggled.emit();
+}
+
 } /* namespace LivePathEffect */
 
 } /* namespace Inkscape */
diff --git a/src/live_effects/parameter/togglebutton.h b/src/live_effects/parameter/togglebutton.h
index 9b1c71185..753af6dbd 100644
--- a/src/live_effects/parameter/togglebutton.h
+++ b/src/live_effects/parameter/togglebutton.h
@@ -2,14 +2,14 @@
 #define INKSCAPE_LIVEPATHEFFECT_PARAMETER_TOGGLEBUTTON_H
 
 /*
- * Inkscape::LivePathEffectParameters
- *
-* Copyright (C) Johan Engelen 2007 <j.b.c.engelen@utwente.nl>
+ * Copyright (C) Jabiertxo Arraiza Cenoz 2014
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
 #include <glib.h>
+#include <sigc++/connection.h>
+#include <sigc++/signal.h>
 
 #include "live_effects/parameter/parameter.h"
 
@@ -17,7 +17,10 @@ namespace Inkscape {
 
 namespace LivePathEffect {
 
-
+/**
+ * class ToggleButtonParam:
+ *    represents a Gtk::ToggleButton as a Live Path Effect parameter
+ */
 class ToggleButtonParam : public Parameter {
 public:
     ToggleButtonParam( const Glib::ustring& label,
@@ -39,6 +42,9 @@ public:
     bool get_value() const { return value; };
 
     inline operator bool() const { return value; };
+    
+    sigc::signal<void>& signal_toggled() { return _signal_toggled; }
+    virtual void toggled();
 
 private:
     ToggleButtonParam(const ToggleButtonParam&);
@@ -46,6 +52,9 @@ private:
 
     bool value;
     bool defvalue;
+    
+    sigc::signal<void> _signal_toggled;
+    sigc::connection _toggled_connection;
 };
 
 
diff --git a/src/widgets/lpe-toolbar.cpp b/src/widgets/lpe-toolbar.cpp
index e9e5af912..94d42b5eb 100644
--- a/src/widgets/lpe-toolbar.cpp
+++ b/src/widgets/lpe-toolbar.cpp
@@ -180,6 +180,7 @@ static void lpetool_unit_changed(GtkAction* /*act*/, GObject* tbl)
 {
     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(tbl, "tracker"));
     Unit const *unit = tracker->getActiveUnit();
+    g_return_if_fail(unit != NULL);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setString("/tools/lpetool/unit", unit->abbr);
 
@@ -281,6 +282,7 @@ void sp_lpetool_toolbox_prep(SPDesktop *desktop, GtkActionGroup* mainActions, GO
     tracker->setActiveUnit(sp_desktop_namedview(desktop)->doc_units);
     g_object_set_data(holder, "tracker", tracker);
     Unit const *unit = tracker->getActiveUnit();
+    g_return_if_fail(unit != NULL);
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     prefs->setString("/tools/lpetool/unit", unit->abbr);
diff --git a/src/widgets/node-toolbar.cpp b/src/widgets/node-toolbar.cpp
index 53161857a..38e3f4fbd 100644
--- a/src/widgets/node-toolbar.cpp
+++ b/src/widgets/node-toolbar.cpp
@@ -229,6 +229,7 @@ static void sp_node_toolbox_coord_changed(gpointer /*shape_editor*/, GObject *tb
         return;
     }
     Unit const *unit = tracker->getActiveUnit();
+    g_return_if_fail(unit != NULL);
 
     NodeTool *nt = get_node_tool();
     if (!nt || !(nt->_selected_nodes) ||nt->_selected_nodes->empty()) {
diff --git a/src/widgets/paintbucket-toolbar.cpp b/src/widgets/paintbucket-toolbar.cpp
index e20811de8..8ddaccf64 100644
--- a/src/widgets/paintbucket-toolbar.cpp
+++ b/src/widgets/paintbucket-toolbar.cpp
@@ -83,6 +83,8 @@ static void paintbucket_offset_changed(GtkAdjustment *adj, GObject *tbl)
     // Don't adjust the offset value because we're saving the
     // unit and it'll be correctly handled on load.
     prefs->setDouble("/tools/paintbucket/offset", (gdouble)gtk_adjustment_get_value(adj));
+
+    g_return_if_fail(unit != NULL);
     prefs->setString("/tools/paintbucket/offsetunits", unit->abbr);
 }
 
diff --git a/src/widgets/rect-toolbar.cpp b/src/widgets/rect-toolbar.cpp
index 6996786e3..c9a09e908 100644
--- a/src/widgets/rect-toolbar.cpp
+++ b/src/widgets/rect-toolbar.cpp
@@ -87,6 +87,7 @@ static void sp_rtb_value_changed(GtkAdjustment *adj, GObject *tbl, gchar const *
 
     UnitTracker* tracker = reinterpret_cast<UnitTracker*>(g_object_get_data( tbl, "tracker" ));
     Unit const *unit = tracker->getActiveUnit();
+    g_return_if_fail(unit != NULL);
 
     if (DocumentUndo::getUndoSensitive(sp_desktop_document(desktop))) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -180,6 +181,7 @@ static void rect_tb_event_attr_changed(Inkscape::XML::Node * /*repr*/, gchar con
     UnitTracker* tracker = reinterpret_cast<UnitTracker*>( g_object_get_data( tbl, "tracker" ) );
     Unit const *unit = tracker->getActiveUnit();
     Unit const *doc_unit = sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units;
+    g_return_if_fail(unit != NULL);
 
     gpointer item = g_object_get_data( tbl, "item" );
     if (item && SP_IS_RECT(item)) {
diff --git a/src/widgets/select-toolbar.cpp b/src/widgets/select-toolbar.cpp
index 284e436bf..d45fb7e4d 100644
--- a/src/widgets/select-toolbar.cpp
+++ b/src/widgets/select-toolbar.cpp
@@ -73,6 +73,7 @@ sp_selection_layout_widget_update(SPWidget *spw, Inkscape::Selection *sel)
         if ( bbox ) {
             UnitTracker *tracker = reinterpret_cast<UnitTracker*>(g_object_get_data(G_OBJECT(spw), "tracker"));
             Unit const *unit = tracker->getActiveUnit();
+            g_return_if_fail(unit != NULL);
 
             struct { char const *key; double val; } const keyval[] = {
                 { "X", bbox->min()[X] },
@@ -178,6 +179,7 @@ sp_object_layout_any_value_changed(GtkAdjustment *adj, SPWidget *spw)
     gdouble xrel = 0;
     gdouble yrel = 0;
     Unit const *unit = tracker->getActiveUnit();
+    g_return_if_fail(unit != NULL);
 
     GtkAdjustment* a_x = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "X" ) );
     GtkAdjustment* a_y = GTK_ADJUSTMENT( g_object_get_data( G_OBJECT(spw), "Y" ) );