Update to trunk

(bzr r13645.1.165)

100 files changed, 1778 insertions, 1012 deletions

diff --git a/src/live_effects/CMakeLists.txt b/src/live_effects/CMakeLists.txt
index 64364c88c..59ff06a4e 100644
--- a/src/live_effects/CMakeLists.txt
+++ b/src/live_effects/CMakeLists.txt
@@ -27,6 +27,7 @@ set(live_effects_SRC
 	lpe-lattice.cpp
 	lpe-lattice2.cpp
 	lpe-line_segment.cpp
+	lpe-measure-line.cpp
 	lpe-mirror_symmetry.cpp
 	lpe-offset.cpp
 	lpe-parallel.cpp
@@ -68,6 +69,7 @@ set(live_effects_SRC
 	parameter/satellitesarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
+	parameter/fontbutton.cpp
 	parameter/togglebutton.cpp
 	parameter/transformedpoint.cpp
 	parameter/unit.cpp
@@ -105,6 +107,7 @@ set(live_effects_SRC
 	lpe-lattice.h
 	lpe-lattice2.h
 	lpe-line_segment.h
+	lpe-measure-line.h
 	lpe-mirror_symmetry.h
 	lpe-offset.h
 	lpe-parallel.h
@@ -148,6 +151,7 @@ set(live_effects_SRC
 	parameter/satellitesarray.h
 	parameter/random.h
 	parameter/text.h
+	parameter/fontbutton.h
 	parameter/togglebutton.h
 	parameter/transformedpoint.h
 	parameter/unit.h
diff --git a/src/live_effects/Makefile_insert b/src/live_effects/Makefile_insert
deleted file mode 100644
index b5bee55c8..000000000
--- a/src/live_effects/Makefile_insert
+++ /dev/null
@@ -1,115 +0,0 @@
-## Makefile.am fragment sourced by src/Makefile.am.
-
-ink_common_sources += \
-	live_effects/effect.cpp	\
-	live_effects/effect.h	\
-	live_effects/effect-enum.h	\
-	live_effects/lpeobject.cpp	\
-	live_effects/lpeobject.h	\
-	live_effects/lpegroupbbox.cpp	\
-	live_effects/lpegroupbbox.h	\
-	live_effects/lpeobject-reference.cpp	\
-	live_effects/lpeobject-reference.h	\
-	live_effects/lpe-patternalongpath.cpp	\
-	live_effects/lpe-patternalongpath.h	\
-	live_effects/lpe-bendpath.cpp	\
-	live_effects/lpe-bendpath.h	\
-	live_effects/lpe-dynastroke.cpp	\
-	live_effects/lpe-dynastroke.h	\
-	live_effects/lpe-extrude.cpp	\
-	live_effects/lpe-extrude.h	\
-	live_effects/lpe-sketch.cpp	\
-	live_effects/lpe-sketch.h	\
-	live_effects/lpe-knot.cpp	\
-	live_effects/lpe-knot.h	\
-	live_effects/lpe-vonkoch.cpp	\
-	live_effects/lpe-vonkoch.h	\
-	live_effects/lpe-rough-hatches.cpp	\
-	live_effects/lpe-rough-hatches.h	\
-	live_effects/lpe-curvestitch.cpp	\
-	live_effects/lpe-curvestitch.h	\
-	live_effects/lpe-constructgrid.cpp	\
-	live_effects/lpe-constructgrid.h	\
-	live_effects/lpe-fillet-chamfer.cpp	\
-	live_effects/lpe-fillet-chamfer.h	\
-	live_effects/lpe-gears.cpp	\
-	live_effects/lpe-gears.h	\
-	live_effects/lpe-interpolate.cpp	\
-	live_effects/lpe-interpolate.h	\
-	live_effects/lpe-interpolate_points.cpp	\
-	live_effects/lpe-interpolate_points.h	\
-	live_effects/lpe-test-doEffect-stack.cpp	\
-	live_effects/lpe-test-doEffect-stack.h	\
-	live_effects/lpe-bspline.cpp	\
-	live_effects/lpe-bspline.h	\
-	live_effects/lpe-lattice.cpp	\
-	live_effects/lpe-lattice.h	\
-	live_effects/lpe-lattice2.cpp	\
-	live_effects/lpe-lattice2.h	\
-	live_effects/lpe-roughen.cpp	\
-	live_effects/lpe-roughen.h	\
-	live_effects/lpe-show_handles.cpp	\
-	live_effects/lpe-show_handles.h	\
-	live_effects/lpe-simplify.cpp	\
-	live_effects/lpe-simplify.h	\
-	live_effects/lpe-envelope.cpp	\
-	live_effects/lpe-envelope.h	\
-	live_effects/lpe-spiro.cpp	\
-	live_effects/lpe-spiro.h	\
-	live_effects/lpe-tangent_to_curve.cpp	\
-	live_effects/lpe-tangent_to_curve.h	\
-	live_effects/lpe-perp_bisector.cpp	\
-	live_effects/lpe-perp_bisector.h	\
-	live_effects/spiro.h	\
-	live_effects/spiro.cpp	\
-	live_effects/spiro-converters.h	\
-	live_effects/spiro-converters.cpp	\
-	live_effects/lpe-circle_with_radius.cpp	\
-	live_effects/lpe-circle_with_radius.h	\
-	live_effects/lpe-perspective_path.cpp	\
-	live_effects/lpe-perspective_path.h		\
-	live_effects/lpe-perspective-envelope.cpp	\
-	live_effects/lpe-perspective-envelope.h		\
-	live_effects/lpe-mirror_symmetry.cpp	\
-	live_effects/lpe-mirror_symmetry.h	\
-	live_effects/lpe-circle_3pts.cpp	\
-	live_effects/lpe-circle_3pts.h	\
-	live_effects/lpe-transform_2pts.cpp	\
-	live_effects/lpe-transform_2pts.h	\
-	live_effects/lpe-angle_bisector.cpp	\
-	live_effects/lpe-angle_bisector.h	\
-	live_effects/lpe-parallel.cpp	\
-	live_effects/lpe-parallel.h	\
-	live_effects/lpe-copy_rotate.cpp	\
-	live_effects/lpe-copy_rotate.h	\
-	live_effects/lpe-powerstroke.cpp	\
-	live_effects/lpe-powerstroke.h	\
-	live_effects/lpe-powerstroke-interpolators.h	\
-	live_effects/lpe-offset.cpp	\
-	live_effects/lpe-offset.h	\
-	live_effects/lpe-clone-original.cpp	\
-	live_effects/lpe-clone-original.h	\
-	live_effects/lpe-ruler.cpp	\
-	live_effects/lpe-ruler.h	\
-	live_effects/lpe-recursiveskeleton.cpp	\
-	live_effects/lpe-recursiveskeleton.h	\
-	live_effects/lpe-text_label.cpp	\
-	live_effects/lpe-text_label.h	\
-	live_effects/lpe-path_length.cpp	\
-	live_effects/lpe-path_length.h	\
-	live_effects/lpe-line_segment.cpp	\
-	live_effects/lpe-line_segment.h	\
-	live_effects/lpe-bounding-box.cpp	\
-	live_effects/lpe-bounding-box.h	\
-	live_effects/lpe-attach-path.cpp	\
-	live_effects/lpe-attach-path.h	\
-	live_effects/lpe-fill-between-strokes.cpp	\
-	live_effects/lpe-fill-between-strokes.h	\
-	live_effects/lpe-fill-between-many.cpp	\
-	live_effects/lpe-fill-between-many.h	\
-	live_effects/lpe-ellipse_5pts.cpp	\
-	live_effects/lpe-ellipse_5pts.h	\
-	live_effects/lpe-jointype.cpp	\
-	live_effects/lpe-jointype.h	\
-	live_effects/lpe-taperstroke.cpp	\
-	live_effects/lpe-taperstroke.h 	
diff --git a/src/live_effects/effect-enum.h b/src/live_effects/effect-enum.h
index eea26184c..3682aa1bd 100644
--- a/src/live_effects/effect-enum.h
+++ b/src/live_effects/effect-enum.h
@@ -36,6 +36,7 @@ enum EffectType {
     CONSTRUCT_GRID,
     PERP_BISECTOR,
     TANGENT_TO_CURVE,
+    MEASURE_LINE,
     MIRROR_SYMMETRY,
     CIRCLE_3PTS,
     TRANSFORM_2PTS,
diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 5ac5e2407..6899a3161 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -8,12 +8,11 @@
 //#define LPE_ENABLE_TEST_EFFECTS //uncomment for toy effects
 
 #ifdef HAVE_CONFIG_H
-# include "config.h"
+#include <config.h>
 #endif
 
 // include effects:
 #include "live_effects/lpe-patternalongpath.h"
-#include "live_effects/effect.h"
 #include "live_effects/lpe-angle_bisector.h"
 #include "live_effects/lpe-attach-path.h"
 #include "live_effects/lpe-bendpath.h"
@@ -40,6 +39,7 @@
 #include "live_effects/lpe-lattice2.h"
 #include "live_effects/lpe-lattice.h"
 #include "live_effects/lpe-line_segment.h"
+#include "live_effects/lpe-measure-line.h"
 #include "live_effects/lpe-mirror_symmetry.h"
 #include "live_effects/lpe-offset.h"
 #include "live_effects/lpe-parallel.h"
@@ -64,30 +64,15 @@
 #include "live_effects/lpe-vonkoch.h"
 
 #include "xml/node-event-vector.h"
-#include "sp-object.h"
-#include "attributes.h"
 #include "message-stack.h"
-#include "desktop.h"
-#include "inkscape.h"
-#include "document.h"
 #include "document-private.h"
-#include "xml/document.h"
-#include <glibmm/i18n.h>
 #include "ui/tools/pen-tool.h"
+#include "ui/tools/node-tool.h"
 #include "ui/tools-switch.h"
 #include "knotholder.h"
-#include "sp-lpe-item.h"
 #include "live_effects/lpeobject.h"
-#include "live_effects/parameter/parameter.h"
-#include <glibmm/ustring.h>
 #include "display/curve.h"
 
-#include <exception>
-
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/affine.h>
-#include <2geom/pathvector.h>
-
 
 namespace Inkscape {
 
@@ -151,6 +136,8 @@ const Util::EnumData<EffectType> LPETypeData[] = {
     {FILL_BETWEEN_MANY,     N_("Fill between many"),       "fill_between_many"},
     {ELLIPSE_5PTS,          N_("Ellipse by 5 points"),     "ellipse_5pts"},
     {BOUNDING_BOX,          N_("Bounding Box"),            "bounding_box"},
+/* 9.93 */
+    {MEASURE_LINE,          N_("Measure Line"),            "measure-line"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -319,6 +306,9 @@ Effect::New(EffectType lpenr, LivePathEffectObject *lpeobj)
         case TRANSFORM_2PTS:
             neweffect = static_cast<Effect*> ( new LPETransform2Pts(lpeobj) );
             break;
+        case MEASURE_LINE:
+            neweffect = static_cast<Effect*> ( new LPEMeasureLine(lpeobj) );
+            break;
         default:
             g_warning("LivePathEffect::Effect::New called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
@@ -360,9 +350,12 @@ Effect::Effect(LivePathEffectObject *lpeobject)
       oncanvasedit_it(0),
       is_visible(_("Is visible?"), _("If unchecked, the effect remains applied to the object but is temporarily disabled on canvas"), "is_visible", &wr, this, true),
       show_orig_path(false),
+      erase_extra_objects(true),
       lpeobj(lpeobject),
       concatenate_before_pwd2(false),
       sp_lpe_item(NULL),
+      current_zoom(1),
+      upd_params(true),
       sp_curve(NULL),
       provides_own_flash_paths(true), // is automatically set to false if providesOwnFlashPaths() is not overridden
       is_ready(false), // is automatically set to false if providesOwnFlashPaths() is not overridden
@@ -472,7 +465,9 @@ void Effect::doAfterEffect (SPLPEItem const* /*lpeitem*/)
 void Effect::doOnRemove (SPLPEItem const* /*lpeitem*/)
 {
 }
-
+void Effect::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
+{
+}
 //secret impl methods (shhhh!)
 void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
 {
@@ -496,6 +491,7 @@ void Effect::doBeforeEffect_impl(SPLPEItem const* lpeitem)
         sp_lpe_item->apply_to_clippath(sp_lpe_item);
         sp_lpe_item->apply_to_mask(sp_lpe_item);
     }
+    update_helperpath();
 }
 
 /**
@@ -642,15 +638,15 @@ Effect::registerParameter(Parameter * param)
  * Add all registered LPE knotholder handles to the knotholder
  */
 void
-Effect::addHandles(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) {
+Effect::addHandles(KnotHolder *knotholder, SPItem *item) {
     using namespace Inkscape::LivePathEffect;
 
     // add handles provided by the effect itself
-    addKnotHolderEntities(knotholder, desktop, item);
+    addKnotHolderEntities(knotholder, item);
 
     // add handles provided by the effect's parameters (if any)
     for (std::vector<Parameter *>::iterator p = param_vector.begin(); p != param_vector.end(); ++p) {
-        (*p)->addKnotHolderEntities(knotholder, desktop, item);
+        (*p)->addKnotHolderEntities(knotholder, item);
     }
 }
 
@@ -685,6 +681,13 @@ Effect::addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathV
 {
 }
 
+/**
+ * Call to a method on nodetool to update the helper path from the effect
+ */
+void
+Effect::update_helperpath() {
+    Inkscape::UI::Tools::sp_update_helperpath();
+}
 
 /**
  * This *creates* a new widget, management of deletion should be done by the caller
@@ -716,7 +719,7 @@ Effect::newWidget()
 
         ++it;
     }
-
+    upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index ac83d9b75..61de60db8 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -68,7 +68,7 @@ public:
     
     virtual void doAfterEffect (SPLPEItem const* lpeitem);
     virtual void doOnRemove (SPLPEItem const* lpeitem);
-
+    virtual void doOnVisibilityToggled(SPLPEItem const* lpeitem);
     void writeParamsToSVG();
 
     virtual void acceptParamPath (SPPath const* param_path);
@@ -102,8 +102,9 @@ public:
     // /TODO: in view of providesOwnFlashPaths() below, this is somewhat redundant
     //       (but spiro lpe still needs it!)
     virtual LPEPathFlashType pathFlashType() const { return DEFAULT; }
-    void addHandles(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    void addHandles(KnotHolder *knotholder, SPItem *item);
     std::vector<Geom::PathVector> getCanvasIndicators(SPLPEItem const* lpeitem);
+    void update_helperpath();
 
     inline bool providesOwnFlashPaths() const {
         return provides_own_flash_paths || show_orig_path;
@@ -124,6 +125,8 @@ public:
 
     void editNextParamOncanvas(SPItem * item, SPDesktop * desktop);
     bool apply_to_clippath_and_mask;
+    bool erase_extra_objects; // set this to false allow retain extra generated objects, see measure line LPE
+    bool upd_params;
 
 protected:
     Effect(LivePathEffectObject *lpeobject);
@@ -141,7 +144,7 @@ protected:
     void registerParameter(Parameter * param);
     Parameter * getNextOncanvasEditableParam();
 
-    virtual void addKnotHolderEntities(KnotHolder * /*knotholder*/, SPDesktop * /*desktop*/, SPItem * /*item*/) {};
+    virtual void addKnotHolderEntities(KnotHolder * /*knotholder*/, SPItem * /*item*/) {};
 
     virtual void addCanvasIndicators(SPLPEItem const* lpeitem, std::vector<Geom::PathVector> &hp_vec);
 
diff --git a/src/live_effects/lpe-angle_bisector.cpp b/src/live_effects/lpe-angle_bisector.cpp
index 900d29e3a..56d33eb4b 100644
--- a/src/live_effects/lpe-angle_bisector.cpp
+++ b/src/live_effects/lpe-angle_bisector.cpp
@@ -8,16 +8,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-angle_bisector.h"
-
-#include <2geom/path.h>
-#include <2geom/sbasis-to-bezier.h>
-
+#include "2geom/sbasis-to-bezier.h"
 #include "sp-lpe-item.h"
 #include "knot-holder-entity.h"
 #include "knotholder.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-attach-path.cpp b/src/live_effects/lpe-attach-path.cpp
index 21459f322..302165719 100644
--- a/src/live_effects/lpe-attach-path.cpp
+++ b/src/live_effects/lpe-attach-path.cpp
@@ -4,22 +4,14 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
 #include <math.h>
-
 #include "live_effects/lpe-attach-path.h"
-
 #include "display/curve.h"
-#include "sp-item.h"
-#include "2geom/path.h"
 #include "sp-shape.h"
 #include "sp-text.h"
-#include "2geom/bezier-curve.h"
 #include "2geom/path-sink.h"
-#include "parameter/parameter.h"
-#include "live_effects/parameter/point.h"
-#include "parameter/originalpath.h"
-#include "2geom/affine.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-bendpath.cpp b/src/live_effects/lpe-bendpath.cpp
index bc112285f..b1e133292 100644
--- a/src/live_effects/lpe-bendpath.cpp
+++ b/src/live_effects/lpe-bendpath.cpp
@@ -6,27 +6,12 @@
  */
 
 #include "live_effects/lpe-bendpath.h"
-#include "sp-shape.h"
-#include "sp-item.h"
-#include "sp-path.h"
 #include "sp-item-group.h"
-#include "svg/svg.h"
-#include "ui/widget/scalar.h"
-
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
-#include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
-
 #include "knot-holder-entity.h"
 #include "knotholder.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
-#include <algorithm>
-
 using std::vector;
 
 
diff --git a/src/live_effects/lpe-bounding-box.cpp b/src/live_effects/lpe-bounding-box.cpp
index 43a60d482..11fb34e04 100644
--- a/src/live_effects/lpe-bounding-box.cpp
+++ b/src/live_effects/lpe-bounding-box.cpp
@@ -3,18 +3,14 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-bounding-box.h"
 
 #include "display/curve.h"
-#include "sp-item.h"
-#include "2geom/path.h"
 #include "sp-shape.h"
 #include "sp-text.h"
-#include "2geom/bezier-curve.h"
-#include "lpe-bounding-box.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -45,6 +41,7 @@ void LPEBoundingBox::doEffect (SPCurve * curve)
             p.appendNew<Geom::LineSegment>(Geom::Point(bbox->right(), bbox->bottom()));
             p.appendNew<Geom::LineSegment>(Geom::Point(bbox->left(), bbox->bottom()));
             p.appendNew<Geom::LineSegment>(Geom::Point(bbox->left(), bbox->top()));
+            p.close();
             Geom::PathVector out;
             out.push_back(p);
             curve->set_pathvector(out);
diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h
index 7823f00f0..90cf82c19 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -6,8 +6,8 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include "live_effects/effect.h"
 
+#include "live_effects/effect.h"
 #include <vector>
 
 namespace Inkscape {
diff --git a/src/live_effects/lpe-circle_3pts.cpp b/src/live_effects/lpe-circle_3pts.cpp
index dbb1f4b6b..3410b13f2 100644
--- a/src/live_effects/lpe-circle_3pts.cpp
+++ b/src/live_effects/lpe-circle_3pts.cpp
@@ -15,9 +15,10 @@
 #include "live_effects/lpe-circle_3pts.h"
 
 // You might need to include other 2geom files. You can add them here:
-#include <2geom/path.h>
 #include <2geom/circle.h>
 #include <2geom/path-sink.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-circle_with_radius.cpp b/src/live_effects/lpe-circle_with_radius.cpp
index 8f2156044..fcefc4ec6 100644
--- a/src/live_effects/lpe-circle_with_radius.cpp
+++ b/src/live_effects/lpe-circle_with_radius.cpp
@@ -15,9 +15,10 @@
 #include "display/curve.h"
 
 // You might need to include other 2geom files. You can add them here:
-#include <2geom/pathvector.h>
 #include <2geom/circle.h>
 #include <2geom/path-sink.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using namespace Geom;
 
diff --git a/src/live_effects/lpe-clone-original.cpp b/src/live_effects/lpe-clone-original.cpp
index 7541c0be2..10418a02d 100644
--- a/src/live_effects/lpe-clone-original.cpp
+++ b/src/live_effects/lpe-clone-original.cpp
@@ -4,11 +4,10 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-clone-original.h"
-
 #include "display/curve.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-constructgrid.cpp b/src/live_effects/lpe-constructgrid.cpp
index b1e0edaac..8d24f9f47 100644
--- a/src/live_effects/lpe-constructgrid.cpp
+++ b/src/live_effects/lpe-constructgrid.cpp
@@ -10,12 +10,9 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-constructgrid.h"
-
-#include <2geom/path.h>
-#include <2geom/transforms.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-copy_rotate.cpp b/src/live_effects/lpe-copy_rotate.cpp
index efea76039..813f25d3d 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -11,39 +11,18 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
+#include <gtkmm.h>
 #include <gdk/gdk.h>
 #include <2geom/path-intersection.h>
 #include <2geom/sbasis-to-bezier.h>
+#include <2geom/intersection-graph.h>
 #include "live_effects/lpe-copy_rotate.h"
-#include <2geom/path.h>
-#include <2geom/transforms.h>
-#include <2geom/angle.h>
-
-#include "knot-holder-entity.h"
-#include "knotholder.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
 
-namespace CR {
-
-class KnotHolderEntityStartingAngle : public LPEKnotHolderEntity {
-public:
-    KnotHolderEntityStartingAngle(LPECopyRotate *effect) : LPEKnotHolderEntity(effect) {};
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
-    virtual Geom::Point knot_get() const;
-};
-
-class KnotHolderEntityRotationAngle : public LPEKnotHolderEntity {
-public:
-    KnotHolderEntityRotationAngle(LPECopyRotate *effect) : LPEKnotHolderEntity(effect) {};
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
-    virtual Geom::Point knot_get() const;
-};
-
-} // namespace CR
-
 bool 
 pointInTriangle(Geom::Point const &p, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3)
 {
@@ -61,28 +40,31 @@ pointInTriangle(Geom::Point const &p, Geom::Point const &p1, Geom::Point const &
 
 LPECopyRotate::LPECopyRotate(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
-    origin(_("Origin"), _("Origin of the rotation"), "origin", &wr, this, "Adjust the origin of the rotation"),
-    starting_angle(_("Starting:"), _("Angle of the first copy"), "starting_angle", &wr, this, 0.0),
-    rotation_angle(_("Rotation angle:"), _("Angle between two successive copies"), "rotation_angle", &wr, this, 60.0),
-    num_copies(_("Number of copies:"), _("Number of copies of the original path"), "num_copies", &wr, this, 6),
+    origin(_("Origin"), _("Adjust origin of the rotation"), "origin", &wr, this,  _("Adjust origin of the rotation")),
+    starting_point(_("Start point"), _("Starting point to define start angle"), "starting_point", &wr, this, _("Adjust starting point to define start angle")),
+    starting_angle(_("Starting angle"), _("Angle of the first copy"), "starting_angle", &wr, this, 0.0),
+    rotation_angle(_("Rotation angle"), _("Angle between two successive copies"), "rotation_angle", &wr, this, 60.0),
+    num_copies(_("Number of copies"), _("Number of copies of the original path"), "num_copies", &wr, this, 6),
     copies_to_360(_("360º Copies"), _("No rotation angle, fixed to 360º"), "copies_to_360", &wr, this, true),
-    fuse_paths(_("Fuse paths"), _("Fuse paths by helper line, use fill-rule: evenodd for best result"), "fuse_paths", &wr, this, false),
+    fuse_paths(_("Kaleidoskope"), _("Kaleidoskope by helper line, use fill-rule: evenodd for best result"), "fuse_paths", &wr, this, false),
+    join_paths(_("Join paths"), _("Join paths, use fill-rule: evenodd for best result"), "join_paths", &wr, this, false),
     dist_angle_handle(100.0)
 {
     show_orig_path = true;
     _provides_knotholder_entities = true;
-    apply_to_clippath_and_mask = true;
-
     // register all your parameters here, so Inkscape knows which parameters this effect has:
     registerParameter(&copies_to_360);
     registerParameter(&fuse_paths);
+    registerParameter(&join_paths);
     registerParameter(&starting_angle);
+    registerParameter(&starting_point);
     registerParameter(&rotation_angle);
     registerParameter(&num_copies);
     registerParameter(&origin);
 
     num_copies.param_make_integer(true);
     num_copies.param_set_range(0, 1000);
+    apply_to_clippath_and_mask = true;
 }
 
 LPECopyRotate::~LPECopyRotate()
@@ -90,6 +72,41 @@ LPECopyRotate::~LPECopyRotate()
 
 }
 
+Gtk::Widget * LPECopyRotate::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);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            Glib::ustring *tip = param->param_getTooltip();
+            if (widg) {
+                if (param->param_key != "starting_point") {
+                    vbox->pack_start(*widg, true, true, 2);
+                    if (tip) {
+                        widg->set_tooltip_text(*tip);
+                    } else {
+                        widg->set_tooltip_text("");
+                        widg->set_has_tooltip(false);
+                    }
+                }
+            }
+        }
+
+        ++it;
+    }
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+
 void
 LPECopyRotate::doOnApply(SPLPEItem const* lpeitem)
 {
@@ -98,7 +115,7 @@ LPECopyRotate::doOnApply(SPLPEItem const* lpeitem)
 
     A = Point(boundingbox_X.min(), boundingbox_Y.middle());
     B = Point(boundingbox_X.middle(), boundingbox_Y.middle());
-    origin.param_setValue(A);
+    origin.param_setValue(A, true);
     origin.param_update_default(A);
     dist_angle_handle = L2(B - A);
     dir = unit_vector(B - A);
@@ -107,11 +124,6 @@ LPECopyRotate::doOnApply(SPLPEItem const* lpeitem)
 void
 LPECopyRotate::transform_multiply(Geom::Affine const& postmul, bool set)
 {
-    if(fuse_paths) {
-        Geom::Coord angle  = Geom::deg_from_rad(atan(-postmul[1]/postmul[0]));
-        angle += starting_angle;
-        starting_angle.param_set_value(angle);
-    }
     // cycle through all parameters. Most parameters will not need transformation, but path and point params do.
 
     for (std::vector<Parameter *>::iterator it = param_vector.begin(); it != param_vector.end(); ++it) {
@@ -149,14 +161,25 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
     dir = unit_vector(B - A);
     // I first suspected the minus sign to be a bug in 2geom but it is
     // likely due to SVG's choice of coordinate system orientation (max)
+    bool near = Geom::are_near(previous_start_point, (Geom::Point)starting_point, 0.01);
+    if (!near) { 
+        starting_angle.param_set_value(deg_from_rad(-angle_between(dir, starting_point - origin)));
+        if (GDK_SHIFT_MASK) {
+            dist_angle_handle = L2(B - A);
+        } else {
+            dist_angle_handle = L2(starting_point - origin);
+        }
+    }
     start_pos = origin + dir * Rotate(-rad_from_deg(starting_angle)) * dist_angle_handle;
     rot_pos = origin + dir * Rotate(-rad_from_deg(rotation_angle+starting_angle)) * dist_angle_handle;
+    near = Geom::are_near(start_pos, (Geom::Point)starting_point, 0.01);
+    if (!near) { 
+        starting_point.param_setValue(start_pos, true);
+    }
+    previous_start_point = (Geom::Point)starting_point;
     if ( fuse_paths || copies_to_360 ) {
         rot_pos = origin;
     }
-    SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
-    item->apply_to_clippath(item);
-    item->apply_to_mask(item);
 }
 
 void
@@ -238,19 +261,8 @@ LPECopyRotate::setFusion(Geom::PathVector &path_on, Geom::Path divider, double s
             if (i%2 != 0) {
                 Geom::Point A = (Geom::Point)origin;
                 Geom::Point B = origin + dir * Geom::Rotate(-Geom::rad_from_deg((rotation_angle*i)+starting_angle)) * size_divider;
-                Geom::Translate m1(A[0], A[1]);
-                double hyp = Geom::distance(A, B);
-                double c = (B[0] - A[0]) / hyp; // cos(alpha)
-                double s = (B[1] - A[1]) / hyp; // sin(alpha)
-
-                Geom::Affine m2(c, -s, s, c, 0.0, 0.0);
-                Geom::Scale sca(1.0, -1.0);
-
-                Geom::Affine tmp_m = m1.inverse() * m2;
-                m = tmp_m;
-                m = m * sca;
-                m = m * m2.inverse();
-                m = m * m1;
+                Geom::Line ls(A,B);
+                m = Geom::reflection (ls.vector(), A);
             } else {
                 append_path = original;
             }
@@ -391,10 +403,26 @@ LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & p
             output = paths_to_pw(path_out);
         }
     } else {
+        Geom::PathVector output_pv = path_from_piecewise(output , 0.01);
         for (int i = 0; i < num_copies; ++i) {
             Rotate rot(-rad_from_deg(rotation_angle * i));
             Affine t = pre * rot * Translate(origin);
-            output.concat(pwd2_in * t);
+            if (join_paths) {
+                Geom::PathVector join_pv = path_from_piecewise(pwd2_in * t , 0.01);
+                Geom::PathIntersectionGraph *pig = new Geom::PathIntersectionGraph(output_pv, join_pv);
+                if (pig) {
+                    if (!output_pv.empty()) {
+                        output_pv = pig->getUnion();
+                    } else {
+                        output_pv = join_pv;
+                    }
+                }
+            } else {
+                output.concat(pwd2_in * t);
+            }
+        }
+        if (join_paths) {
+            output = paths_to_pw(output_pv);
         }
     }
     return output;
@@ -421,85 +449,6 @@ LPECopyRotate::resetDefaults(SPItem const* item)
     original_bbox(SP_LPE_ITEM(item));
 }
 
-void
-LPECopyRotate::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
-{
-    {
-        KnotHolderEntity *e = new CR::KnotHolderEntityStartingAngle(this);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the starting angle"));
-        knotholder->add(e);
-    }
-    {
-        KnotHolderEntity *e = new CR::KnotHolderEntityRotationAngle(this);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the rotation angle"));
-        knotholder->add(e);
-    }
-};
-
-namespace CR {
-
-using namespace Geom;
-
-void
-KnotHolderEntityStartingAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
-{
-    LPECopyRotate* lpe = dynamic_cast<LPECopyRotate *>(_effect);
-
-    Geom::Point const s = snap_knot_position(p, state);
-
-    // I first suspected the minus sign to be a bug in 2geom but it is
-    // likely due to SVG's choice of coordinate system orientation (max)
-    lpe->starting_angle.param_set_value(deg_from_rad(-angle_between(lpe->dir, s - lpe->origin)));
-    if (state & GDK_SHIFT_MASK) {
-        lpe->dist_angle_handle = L2(lpe->B - lpe->A);
-    } else {
-        lpe->dist_angle_handle = L2(p - lpe->origin);
-    }
-
-    // FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.
-    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
-}
-
-void
-KnotHolderEntityRotationAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
-{
-    LPECopyRotate* lpe = dynamic_cast<LPECopyRotate *>(_effect);
-
-    Geom::Point const s = snap_knot_position(p, state);
-
-    // I first suspected the minus sign to be a bug in 2geom but it is
-    // likely due to SVG's choice of coordinate system orientation (max)
-    lpe->rotation_angle.param_set_value(deg_from_rad(-angle_between(lpe->dir, s - lpe->origin)) - lpe->starting_angle);
-    if (state & GDK_SHIFT_MASK) {
-        lpe->dist_angle_handle = L2(lpe->B - lpe->A);
-    } else {
-        lpe->dist_angle_handle = L2(p - lpe->origin);
-    }
-
-    // FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.
-    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
-}
-
-Geom::Point
-KnotHolderEntityStartingAngle::knot_get() const
-{
-    LPECopyRotate const *lpe = dynamic_cast<LPECopyRotate const*>(_effect);
-    return lpe->start_pos;
-}
-
-Geom::Point
-KnotHolderEntityRotationAngle::knot_get() const
-{
-    LPECopyRotate const *lpe = dynamic_cast<LPECopyRotate const*>(_effect);
-    return lpe->rot_pos;
-}
-
-} // namespace CR
-
-/* ######################## */
-
 } //namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-copy_rotate.h b/src/live_effects/lpe-copy_rotate.h
index 87af867df..c2ae2daf1 100644
--- a/src/live_effects/lpe-copy_rotate.h
+++ b/src/live_effects/lpe-copy_rotate.h
@@ -21,12 +21,6 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
-namespace CR {
-// we need a separate namespace to avoid clashes with LPEPerpBisector
-class KnotHolderEntityStartingAngle;
-class KnotHolderEntityRotationAngle;
-}
-
 class LPECopyRotate : public Effect, GroupBBoxEffect {
 public:
     LPECopyRotate(LivePathEffectObject *lpeobject);
@@ -38,26 +32,25 @@ public:
     virtual void split(Geom::PathVector &path_in, Geom::Path const &divider);
     virtual void resetDefaults(SPItem const* item);
     virtual void transform_multiply(Geom::Affine const& postmul, bool set);
-    /* the knotholder entity classes must be declared friends */
-    friend class CR::KnotHolderEntityStartingAngle;
-    friend class CR::KnotHolderEntityRotationAngle;
-    void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
-
+    virtual Gtk::Widget * newWidget();
 protected:
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
 
 private:
     PointParam origin;
+    PointParam starting_point;
     ScalarParam starting_angle;
     ScalarParam rotation_angle;
     ScalarParam num_copies;
     BoolParam copies_to_360;
     BoolParam fuse_paths;
+    BoolParam join_paths;
     Geom::Point A;
     Geom::Point B;
     Geom::Point dir;
     Geom::Point start_pos;
     Geom::Point rot_pos;
+    Geom::Point previous_start_point;
     double dist_angle_handle;
     LPECopyRotate(const LPECopyRotate&);
     LPECopyRotate& operator=(const LPECopyRotate&);
diff --git a/src/live_effects/lpe-curvestitch.cpp b/src/live_effects/lpe-curvestitch.cpp
index 609447f26..38cbeaac0 100644
--- a/src/live_effects/lpe-curvestitch.cpp
+++ b/src/live_effects/lpe-curvestitch.cpp
@@ -13,23 +13,16 @@
  */
 
 #include "ui/widget/scalar.h"
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-curvestitch.h"
 
-#include "sp-item.h"
 #include "sp-path.h"
 #include "svg/svg.h"
 #include "xml/repr.h"
 
-#include <2geom/path.h>
-#include <2geom/piecewise.h>
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/affine.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-dynastroke.cpp b/src/live_effects/lpe-dynastroke.cpp
index aeecd5d5c..50bbe6451 100644
--- a/src/live_effects/lpe-dynastroke.cpp
+++ b/src/live_effects/lpe-dynastroke.cpp
@@ -14,14 +14,10 @@
 #include "display/curve.h"
 //# include <libnr/n-art-bpath.h>
 
-#include <2geom/path.h>
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
 #include <2geom/sbasis-math.h>
-#include <2geom/piecewise.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-ellipse_5pts.cpp b/src/live_effects/lpe-ellipse_5pts.cpp
index 4c953bcda..28e7058d7 100644
--- a/src/live_effects/lpe-ellipse_5pts.cpp
+++ b/src/live_effects/lpe-ellipse_5pts.cpp
@@ -12,16 +12,14 @@
  */
 
 #include "live_effects/lpe-ellipse_5pts.h"
-
-// You might need to include other 2geom files. You can add them here:
-#include <glibmm/i18n.h>
-#include <2geom/path.h>
 #include <2geom/circle.h>
 #include <2geom/ellipse.h>
 #include <2geom/path-sink.h>
 #include "inkscape.h"
 #include "desktop.h"
 #include "message-stack.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -171,7 +169,7 @@ LPEEllipse5Pts::doEffect_path (Geom::PathVector const & path_in)
 
     // figure out if we have a slice, guarding against rounding errors
 
-    Path p(Geom::Point(cos(0), sin(0)));
+    Geom::Path p(Geom::Point(cos(0), sin(0)));
 
     double end = 2 * M_PI;
     for (s = 0; s < end; s += M_PI_2) {
diff --git a/src/live_effects/lpe-envelope.cpp b/src/live_effects/lpe-envelope.cpp
index e873c0b15..61a696435 100644
--- a/src/live_effects/lpe-envelope.cpp
+++ b/src/live_effects/lpe-envelope.cpp
@@ -5,22 +5,10 @@
  */
 
 #include "live_effects/lpe-envelope.h"
-#include "sp-shape.h"
-#include "sp-item.h"
-#include "sp-path.h"
-#include "sp-item-group.h"
 #include "display/curve.h"
-#include "svg/svg.h"
-#include "ui/widget/scalar.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
-#include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
-
-#include <algorithm>
 using std::vector;
 
 namespace Inkscape {
@@ -61,7 +49,7 @@ Geom::Piecewise<Geom::D2<Geom::SBasis> >
 LPEEnvelope::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
 {
 
-    if(xx.get_value() == false && yy.get_value() == false)
+    if(!xx.get_value() && !yy.get_value())
     {
         return pwd2_in;
     }
@@ -172,7 +160,7 @@ LPEEnvelope::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
     output_y =  ybis*(compose((uskeleton1),x1) + y1*compose(n1,x1) )
             +    y*(compose((uskeleton3),x3) + y3*compose(n3,x3) );
     output_y /= (boundingbox_Y.extent());
-    if(xx.get_value() == false && yy.get_value() == true)
+    if(!xx.get_value() && yy.get_value())
     {
             return output_y;
     }
@@ -181,13 +169,13 @@ LPEEnvelope::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd
     output_x =    x*(compose((uskeleton2),y2) + -x2*compose(n2,y2) )
             + xbis*(compose((uskeleton4),y4) + -x4*compose(n4,y4) );
     output_x /= (boundingbox_X.extent());
-    if(xx.get_value() == true && yy.get_value() == false)
+    if(xx.get_value() && !yy.get_value())
     {
             return output_x;
     }
 
     /*output : Deformation by Up, Left, Right and Down Bend Paths*/
-    if(xx.get_value() == true && yy.get_value() == true)
+    if(xx.get_value() && yy.get_value())
     {
         Piecewise<SBasis> xsqr = x*xbis; /* xsqr = x * (BBox_X - x) */
         Piecewise<SBasis> ysqr = y*ybis; /* xsqr = y * (BBox_Y - y) */
diff --git a/src/live_effects/lpe-extrude.cpp b/src/live_effects/lpe-extrude.cpp
index 8b3f4714a..daa30d45a 100644
--- a/src/live_effects/lpe-extrude.cpp
+++ b/src/live_effects/lpe-extrude.cpp
@@ -12,15 +12,10 @@
  */
 
 #include "live_effects/lpe-extrude.h"
-
+#include "sp-item.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
-#include <2geom/path.h>
-#include <2geom/piecewise.h>
-#include <2geom/transforms.h>
-#include <algorithm>
-
-#include "sp-item.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -66,7 +61,7 @@ LPEExtrude::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2
     using namespace Geom;
 
     // generate connecting lines (the 'sides' of the extrusion)
-    Path path(Point(0.,0.));
+    Geom::Path path(Point(0.,0.));
     path.appendNew<Geom::LineSegment>( extrude_vector.getVector() );
     Piecewise<D2<SBasis> > connector = path.toPwSb();
 
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index 574ec3580..1e2eadfdb 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -9,12 +9,9 @@
 #include "live_effects/lpe-fill-between-many.h"
 
 #include "display/curve.h"
-#include "sp-item.h"
-#include "2geom/path.h"
 #include "sp-shape.h"
 #include "sp-text.h"
-#include "2geom/bezier-curve.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
 namespace Inkscape {
@@ -60,6 +57,9 @@ void LPEFillBetweenMany::doEffect (SPCurve * curve)
     if (!res_pathv.empty()) {
         res_pathv.front().close();
     }
+    if (res_pathv.empty()) {
+        res_pathv = curve->get_pathvector();
+    }
     curve->set_pathvector(res_pathv);
 }
 
diff --git a/src/live_effects/lpe-fill-between-strokes.cpp b/src/live_effects/lpe-fill-between-strokes.cpp
index 89ea80545..0dbebdf26 100644
--- a/src/live_effects/lpe-fill-between-strokes.cpp
+++ b/src/live_effects/lpe-fill-between-strokes.cpp
@@ -3,17 +3,13 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-fill-between-strokes.h"
 
 #include "display/curve.h"
-#include "sp-item.h"
-#include "2geom/path.h"
 #include "sp-shape.h"
 #include "sp-text.h"
-#include "2geom/bezier-curve.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-fillet-chamfer.cpp b/src/live_effects/lpe-fillet-chamfer.cpp
index 268e08921..2bbd3dbab 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -16,6 +16,7 @@
 #include <2geom/elliptical-arc.h>
 #include "knotholder.h"
 #include <boost/optional.hpp>
+
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
diff --git a/src/live_effects/lpe-gears.cpp b/src/live_effects/lpe-gears.cpp
index d4d695542..dad520041 100644
--- a/src/live_effects/lpe-gears.cpp
+++ b/src/live_effects/lpe-gears.cpp
@@ -7,15 +7,9 @@
  */
 
 #include "live_effects/lpe-gears.h"
-
-#include <vector>
-
-#include <glibmm/i18n.h>
-
-#include <2geom/d2.h>
-#include <2geom/sbasis.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/path.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using std::vector;
 using namespace Geom;
@@ -212,7 +206,8 @@ namespace LivePathEffect {
 LPEGears::LPEGears(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     teeth(_("_Teeth:"), _("The number of teeth"), "teeth", &wr, this, 10),
-    phi(_("_Phi:"), _("Tooth pressure angle (typically 20-25 deg).  The ratio of teeth not in contact."), "phi", &wr, this, 5)
+    phi(_("_Phi:"), _("Tooth pressure angle (typically 20-25 deg).  The ratio of teeth not in contact."), "phi", &wr, this, 5),
+    min_radius(_("Min Radius:"), _("Minimum radius, low values can be slow"), "min_radius", &wr, this, 5.0)
 {
     /* Tooth pressure angle: The angle between the tooth profile and a perpendicular to the pitch
      * circle, usually at the point where the pitch circle meets the tooth profile. Standard angles
@@ -223,8 +218,10 @@ LPEGears::LPEGears(LivePathEffectObject *lpeobject) :
 
     teeth.param_make_integer();
     teeth.param_set_range(3, 1e10);
-    registerParameter( dynamic_cast<Parameter *>(&teeth) );
-    registerParameter( dynamic_cast<Parameter *>(&phi) );
+    min_radius.param_set_range(0.01, 9999.0);
+    registerParameter(&teeth);
+    registerParameter(&phi);
+    registerParameter(&min_radius);
 }
 
 LPEGears::~LPEGears()
@@ -247,12 +244,17 @@ LPEGears::doEffect_path (Geom::PathVector const &path_in)
     gear->angle(atan2((*it).initialPoint() - gear_centre));
 
     ++it;
-	if ( it == gearpath.end() ) return path_out;
-    gear->pitch_radius(Geom::distance(gear_centre, (*it).finalPoint()));
+    if ( it == gearpath.end() ) return path_out;
+    double radius = Geom::distance(gear_centre, (*it).finalPoint());
+    radius = radius < min_radius?min_radius:radius;
+    gear->pitch_radius(radius);
 
     path_out.push_back( gear->path());
-
+    
     for (++it; it != gearpath.end() ; ++it) {
+        if (are_near((*it).initialPoint(), (*it).finalPoint())) {
+            continue;
+        }
         // iterate through Geom::Curve in path_in
         Gear* gearnew = new Gear(gear->spawn( (*it).finalPoint() ));
         path_out.push_back( gearnew->path() );
diff --git a/src/live_effects/lpe-gears.h b/src/live_effects/lpe-gears.h
index 5dd6dd239..57b49d2b5 100644
--- a/src/live_effects/lpe-gears.h
+++ b/src/live_effects/lpe-gears.h
@@ -27,6 +27,7 @@ public:
 private:
     ScalarParam teeth;
     ScalarParam phi;
+    ScalarParam min_radius;
 
     LPEGears(const LPEGears&);
     LPEGears& operator=(const LPEGears&);
diff --git a/src/live_effects/lpe-interpolate.cpp b/src/live_effects/lpe-interpolate.cpp
index 74c7efd90..e95dc5f38 100644
--- a/src/live_effects/lpe-interpolate.cpp
+++ b/src/live_effects/lpe-interpolate.cpp
@@ -9,18 +9,15 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-interpolate.h"
 
-#include <2geom/path.h>
 #include <2geom/sbasis-to-bezier.h>
-#include <2geom/piecewise.h>
-#include <2geom/sbasis-geometric.h>
 
 #include "sp-path.h"
 #include "display/curve.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-interpolate_points.cpp b/src/live_effects/lpe-interpolate_points.cpp
index cf70832ee..0a0bcea14 100644
--- a/src/live_effects/lpe-interpolate_points.cpp
+++ b/src/live_effects/lpe-interpolate_points.cpp
@@ -12,10 +12,9 @@
  */
 
 #include "live_effects/lpe-interpolate_points.h"
-
-#include <2geom/path.h>
-
 #include "live_effects/lpe-powerstroke-interpolators.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-jointype.cpp b/src/live_effects/lpe-jointype.cpp
index fe42932be..dacb87dd9 100644
--- a/src/live_effects/lpe-jointype.cpp
+++ b/src/live_effects/lpe-jointype.cpp
@@ -10,19 +10,17 @@
 #include "live_effects/parameter/enum.h"
 #include "helper/geom-pathstroke.h"
 
-#include "sp-shape.h"
 #include "style.h"
-#include "xml/repr.h"
-#include "sp-paint-server.h"
 #include "svg/svg-color.h"
 #include "desktop-style.h"
 #include "svg/css-ostringstream.h"
 #include "display/curve.h"
 
-#include <2geom/path.h>
 #include <2geom/elliptical-arc.h>
 
 #include "lpe-jointype.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-knot.cpp b/src/live_effects/lpe-knot.cpp
index a033a6c4a..2defecb77 100644
--- a/src/live_effects/lpe-knot.cpp
+++ b/src/live_effects/lpe-knot.cpp
@@ -16,28 +16,24 @@
 #include "sp-path.h"
 #include "display/curve.h"
 #include "live_effects/lpe-knot.h"
-#include "svg/svg.h"
 #include "style.h"
 #include "knot-holder-entity.h"
 #include "knotholder.h"
 
-#include <glibmm/i18n.h>
 #include <gdk/gdk.h>
 
 #include <2geom/sbasis-to-bezier.h>
-#include <2geom/sbasis.h>
-#include <2geom/d2.h>
-#include <2geom/path.h>
 #include <2geom/bezier-to-sbasis.h>
 #include <2geom/basic-intersection.h>
-#include <2geom/exception.h>
+#include "helper/geom.h"
 
 // for change crossing undo
 #include "verbs.h"
 #include "document.h"
 #include "document-undo.h"
 
-#include <exception>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -101,7 +97,7 @@ findShadowedTime(Geom::Path const &patha, std::vector<Geom::Point> const &pt_and
 
     Affine mat = from_basis( T, N, pt_and_dir[0] );
     mat = mat.inverse();
-    Path p = patha * mat;
+    Geom::Path p = patha * mat;
     
     std::vector<double> times;
     
@@ -399,14 +395,14 @@ LPEKnot::doEffect_path (Geom::PathVector const &path_in)
     if (gpaths.size()==0){
         return path_in;
     }
-
-    for (unsigned comp=0; comp<path_in.size(); comp++){
+    Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(path_in);
+    for (unsigned comp=0; comp<original_pathv.size(); comp++){
 
         //find the relevant path component in gpaths (required to allow groups!)
         //Q: do we always receive the group members in the same order? can we rest on that?
         unsigned i0 = 0;
         for (i0=0; i0<gpaths.size(); i0++){
-            if (path_in[comp]==gpaths[i0]) break;
+            if (original_pathv[comp]==gpaths[i0]) break;
         }
         if (i0 == gpaths.size() ) {THROW_EXCEPTION("lpe-knot error: group member not recognized");}// this should not happen...
 
@@ -484,7 +480,7 @@ LPEKnot::doEffect_path (Geom::PathVector const &path_in)
 //                std::cout<<"fusing first and last component\n";
                 ++beg_comp;
                 --end_comp;
-                Path first = gpaths[i0].portion(dom.back());
+                Geom::Path first = gpaths[i0].portion(dom.back());
                 //FIXME: stitching should not be necessary (?!?)
                 first.setStitching(true);
                 first.append(gpaths[i0].portion(dom.front()));
@@ -521,7 +517,7 @@ collectPathsAndWidths (SPLPEItem const *lpeitem, Geom::PathVector &paths, std::v
             c = SP_SHAPE(lpeitem)->getCurve();
         }
         if (c) {
-            Geom::PathVector subpaths = c->get_pathvector();
+            Geom::PathVector subpaths = pathv_to_linear_and_cubic_beziers(c->get_pathvector());
             for (unsigned i=0; i<subpaths.size(); i++){
                 paths.push_back(subpaths[i]);
                 //FIXME: do we have to be more carefull when trying to access stroke width?
@@ -619,10 +615,10 @@ LPEKnot::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::Pat
     hp_vec.push_back(pathv);
 }
 
-void LPEKnot::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+void LPEKnot::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     KnotHolderEntity *e = new KnotHolderEntityCrossingSwitcher(this);
-    e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+    e->create( NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                _("Drag to select a crossing, click to flip it") );
     knotholder->add(e);
 };
diff --git a/src/live_effects/lpe-knot.h b/src/live_effects/lpe-knot.h
index 95bfaf6e1..ac518b97c 100644
--- a/src/live_effects/lpe-knot.h
+++ b/src/live_effects/lpe-knot.h
@@ -61,7 +61,7 @@ public:
   
   /* the knotholder entity classes must be declared friends */
   friend class KnotHolderEntityCrossingSwitcher;
-  void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+  void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
 protected:
   virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
diff --git a/src/live_effects/lpe-lattice.cpp b/src/live_effects/lpe-lattice.cpp
index 3c23e349e..acffed000 100644
--- a/src/live_effects/lpe-lattice.cpp
+++ b/src/live_effects/lpe-lattice.cpp
@@ -6,7 +6,7 @@
  * Authors:
  *   Johan Engelen <j.b.c.engelen@utwente.nl>
  *   Steren Giannini
- *   Noé Falzon
+ *   No� Falzon
  *   Victor Navez
 *
 * Copyright (C) 2007-2008 Authors 
@@ -16,23 +16,12 @@
 
 #include "live_effects/lpe-lattice.h"
 
-#include "sp-shape.h"
-#include "sp-item.h"
-#include "sp-path.h"
 #include "display/curve.h"
-#include "svg/svg.h"
 
-#include <2geom/sbasis.h>
 #include <2geom/sbasis-2d.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
-#include <2geom/transforms.h>
-
-#include "desktop.h" // TODO: should be factored out (see below)
-
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 using namespace Geom;
 
 namespace Inkscape {
diff --git a/src/live_effects/lpe-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp
index 0c403daec..e827491c0 100644
--- a/src/live_effects/lpe-lattice2.cpp
+++ b/src/live_effects/lpe-lattice2.cpp
@@ -6,7 +6,7 @@
  * Authors:
  *   Johan Engelen <j.b.c.engelen@utwente.nl>
  *   Steren Giannini
- *   Noé Falzon
+ *   No� Falzon
  *   Victor Navez
  *   ~suv
  *   Jabiertxo Arraiza
@@ -16,26 +16,15 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <gtkmm.h>
 #include "live_effects/lpe-lattice2.h"
-
-#include <gtkmm/expander.h>
-
-#include "sp-shape.h"
-#include "sp-item.h"
-#include "sp-path.h"
 #include "display/curve.h"
-#include "svg/svg.h"
 #include "helper/geom.h"
-#include <2geom/path.h>
-#include <2geom/sbasis.h>
 #include <2geom/sbasis-2d.h>
-#include "helper/geom-curves.h"
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
-#include <2geom/transforms.h>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using namespace Geom;
 
@@ -280,7 +269,7 @@ void
 LPELattice2::onExpanderChanged()
 {
     expanded = expander->get_expanded();
-    if(expander->get_expanded()) {
+    if(expanded) {
         expander->set_label (Glib::ustring(_("Hide Points")));
     } else {
         expander->set_label (Glib::ustring(_("Show Points")));
diff --git a/src/live_effects/lpe-lattice2.h b/src/live_effects/lpe-lattice2.h
index 8d0c18a3a..59a0350d3 100644
--- a/src/live_effects/lpe-lattice2.h
+++ b/src/live_effects/lpe-lattice2.h
@@ -18,9 +18,9 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include "live_effects/parameter/enum.h"
-#include <gtkmm/widget.h>
+
 #include "live_effects/effect.h"
+#include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/point.h"
 #include "live_effects/lpegroupbbox.h"
 
diff --git a/src/live_effects/lpe-line_segment.cpp b/src/live_effects/lpe-line_segment.cpp
index dfd8aea8f..cc024fb92 100644
--- a/src/live_effects/lpe-line_segment.cpp
+++ b/src/live_effects/lpe-line_segment.cpp
@@ -13,10 +13,8 @@
 
 #include "live_effects/lpe-line_segment.h"
 #include "ui/tools/lpe-tool.h"
-
-#include <2geom/pathvector.h>
-#include <2geom/geom.h>
-#include <2geom/bezier-curve.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-measure-line.cpp b/src/live_effects/lpe-measure-line.cpp
new file mode 100644
index 000000000..af2a8e919
--- /dev/null
+++ b/src/live_effects/lpe-measure-line.cpp
@@ -0,0 +1,843 @@
+/*
+ * Author(s):
+ *   Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ * Some code and ideas migrated from dimensioning.py by
+ * Johannes B. Rutzmoser, johannes.rutzmoser (at) googlemail (dot) com
+ * https://github.com/Rutzmoser/inkscape_dimensioning
+ * Copyright (C) 2014 Author(s)
+
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include "live_effects/lpe-measure-line.h"
+#include <pangomm/fontdescription.h>
+#include "ui/dialog/livepatheffect-editor.h"
+#include <libnrtype/font-lister.h>
+#include "inkscape.h"
+#include "xml/node.h"
+#include "xml/sp-css-attr.h"
+#include "preferences.h"
+#include "util/units.h"
+#include "svg/svg-length.h"
+#include "svg/svg-color.h"
+#include "svg/svg.h"
+#include "display/curve.h"
+#include "2geom/affine.h"
+#include "style.h"
+#include "sp-root.h"
+#include "sp-defs.h"
+#include "sp-item.h"
+#include "sp-shape.h"
+#include "sp-path.h"
+#include "document.h"
+#include <iomanip>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
+using namespace Geom;
+namespace Inkscape {
+namespace LivePathEffect {
+
+static const Util::EnumData<OrientationMethod> OrientationMethodData[] = {
+    { OM_HORIZONTAL, N_("Horizontal"), "horizontal" }, 
+    { OM_VERTICAL, N_("Vertical"), "vertical" },
+    { OM_PARALLEL, N_("Parallel"), "parallel" }
+};
+static const Util::EnumDataConverter<OrientationMethod> OMConverter(OrientationMethodData, OM_END);
+
+LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    unit(_("Unit*"), _("Unit"), "unit", &wr, this, "px"),
+    fontbutton(_("Font*"), _("Font Selector"), "fontbutton", &wr, this),
+    orientation(_("Orientation"), _("Orientation method"), "orientation", OMConverter, &wr, this, OM_PARALLEL, false),
+    curve_linked(_("Curve on origin"), _("Curve on origin, set 0 to start/end"), "curve_linked", &wr, this, 1),
+    precision(_("Precision*"), _("Precision"), "precision", &wr, this, 2),
+    position(_("Position*"), _("Position"), "position", &wr, this, 5),
+    text_top_bottom(_("Text top/bottom*"), _("Text top/bottom"), "text_top_bottom", &wr, this, 0),
+    text_right_left(_("Text right/left*"), _("Text right/left"), "text_right_left", &wr, this, 0),
+    helpline_distance(_("Helpline distance*"), _("Helpline distance"), "helpline_distance", &wr, this, 0.0),
+    helpline_overlap(_("Helpline overlap*"), _("Helpline overlap"), "helpline_overlap", &wr, this, 2.0),
+    scale(_("Scale*"), _("Scaling factor"), "scale", &wr, this, 1.0),
+    format(_("Format*"), _("Format the number ex:{measure} {unit}, return to save"), "format", &wr, this,"{measure}{unit}"),
+    id_origin("id_origin", "id_origin", "id_origin", &wr, this,""),
+    arrows_outside(_("Arrows outside"), _("Arrows outside"), "arrows_outside", &wr, this, false),
+    flip_side(_("Flip side*"), _("Flip side"), "flip_side", &wr, this, false),
+    scale_sensitive(_("Scale sensitive*"), _("Costrained scale sensitive to transformed containers"), "scale_sensitive", &wr, this, true),
+    local_locale(_("Local Number Format*"), _("Local number format"), "local_locale", &wr, this, true),
+    line_group_05(_("Line Group 0.5*"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
+    rotate_anotation(_("Rotate Anotation*"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true),
+    hide_back(_("Hide if label over*"), _("Hide DIN line if label over"), "hide_back", &wr, this, true),
+    dimline_format(_("CSS DIN line*"), _("Override CSS to DIN line, return to save, empty to reset to DIM"), "dimline_format", &wr, this,""),
+    helperlines_format(_("CSS helpers*"), _("Override CSS to helper lines, return to save, empty to reset to DIM"), "helperlines_format", &wr, this,""),
+    anotation_format(_("CSS anotation*"), _("Override CSS to anotation text, return to save, empty to reset to DIM"), "anotation_format", &wr, this,""),
+    arrows_format(_("CSS arrows*"), _("Override CSS to arrows, return to save, empty to reset DIM"), "arrows_format", &wr, this,""),
+    expanded(false)
+{
+    registerParameter(&unit);
+    registerParameter(&fontbutton);
+    registerParameter(&orientation);
+    registerParameter(&curve_linked);
+    registerParameter(&precision);
+    registerParameter(&position);
+    registerParameter(&text_top_bottom);
+    registerParameter(&text_right_left);
+    registerParameter(&helpline_distance);
+    registerParameter(&helpline_overlap);
+    registerParameter(&scale);
+    registerParameter(&format);
+    registerParameter(&arrows_outside);
+    registerParameter(&flip_side);
+    registerParameter(&scale_sensitive);
+    registerParameter(&local_locale);
+    registerParameter(&line_group_05);
+    registerParameter(&rotate_anotation);
+    registerParameter(&hide_back);
+    registerParameter(&dimline_format);
+    registerParameter(&helperlines_format);
+    registerParameter(&anotation_format);
+    registerParameter(&arrows_format);
+    registerParameter(&id_origin);
+    id_origin.param_hide_canvas_text();
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    Glib::ustring fontbutton_value = prefs->getString("/live_effects/measure-line/fontbutton");
+    if(fontbutton_value.empty()){
+        fontbutton_value = "Sans 10";
+    }
+    fontbutton.param_update_default(fontbutton_value);
+    scale.param_update_default(prefs->getDouble("/live_effects/measure-line/scale", 1.0));
+    precision.param_update_default(prefs->getInt("/live_effects/measure-line/precision", 2));
+    position.param_update_default(prefs->getDouble("/live_effects/measure-line/position", 10.0));
+    text_top_bottom.param_update_default(prefs->getDouble("/live_effects/measure-line/text_top_bottom", 5.0));
+    helpline_distance.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_distance", 0.0));
+    helpline_overlap.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_overlap", 0.0));
+    Glib::ustring unit_value = prefs->getString("/live_effects/measure-line/unit");
+    if(unit_value.empty()){
+        unit_value = "px";
+    }
+    unit.param_update_default(unit_value);
+    Glib::ustring format_value = prefs->getString("/live_effects/measure-line/format");
+    if(format_value.empty()){
+        format_value = "{measure}{unit}";
+    }
+    format.param_update_default(format_value);
+    dimline_format.param_update_default(prefs->getString("/live_effects/measure-line/dimline_format"));
+    helperlines_format.param_update_default(prefs->getString("/live_effects/measure-line/helperlines_format"));
+    anotation_format.param_update_default(prefs->getString("/live_effects/measure-line/anotation_format"));
+    arrows_format.param_update_default(prefs->getString("/live_effects/measure-line/arrows_format"));
+    flip_side.param_update_default(prefs->getBool("/live_effects/measure-line/flip_side"));
+    scale_sensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_sensitive"));
+    local_locale.param_update_default(prefs->getBool("/live_effects/measure-line/local_locale"));
+    line_group_05.param_update_default(prefs->getBool("/live_effects/measure-line/line_group_05"));
+    rotate_anotation.param_update_default(prefs->getBool("/live_effects/measure-line/rotate_anotation"));
+    hide_back.param_update_default(prefs->getBool("/live_effects/measure-line/hide_back"));
+    format.param_hide_canvas_text();
+    dimline_format.param_hide_canvas_text();
+    helperlines_format.param_hide_canvas_text();
+    anotation_format.param_hide_canvas_text();
+    arrows_format.param_hide_canvas_text();
+    precision.param_set_range(0, 100);
+    precision.param_set_increments(1, 1);
+    precision.param_set_digits(0);
+    precision.param_make_integer(true);
+    curve_linked.param_set_range(0, 999);
+    curve_linked.param_set_increments(1, 1);
+    curve_linked.param_set_digits(0);
+    curve_linked.param_make_integer(true);
+    precision.param_make_integer(true);
+    position.param_set_range(-999999.0, 999999.0);
+    position.param_set_increments(1, 1);
+    position.param_set_digits(2);
+    text_top_bottom.param_set_range(-999999.0, 999999.0);
+    text_top_bottom.param_set_increments(1, 1);
+    text_top_bottom.param_set_digits(2);
+    text_right_left.param_set_range(-999999.0, 999999.0);
+    text_right_left.param_set_increments(1, 1);
+    text_right_left.param_set_digits(2);
+    helpline_distance.param_set_range(-999999.0, 999999.0);
+    helpline_distance.param_set_increments(1, 1);
+    helpline_distance.param_set_digits(2);
+    helpline_overlap.param_set_range(-999999.0, 999999.0);
+    helpline_overlap.param_set_increments(1, 1);
+    helpline_overlap.param_set_digits(2);
+    start_stored = Geom::Point(0,0);
+    end_stored = Geom::Point(0,0);
+}
+
+LPEMeasureLine::~LPEMeasureLine() {}
+
+void swap(Geom::Point &A, Geom::Point &B){
+    Geom::Point tmp = A;
+    A = B;
+    B = tmp;
+}
+
+void
+LPEMeasureLine::createArrowMarker(const char * mode)
+{
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    Inkscape::XML::Document *xml_doc = document->getReprDoc();
+    SPObject *elemref = NULL;
+    Inkscape::XML::Node *arrow = NULL;
+    if (elemref = document->getObjectById(mode)) {
+        Inkscape::XML::Node *arrow= elemref->getRepr();
+        if (arrow) {
+            arrow->setAttribute("sodipodi:insensitive", "true");
+            arrow->setAttribute("transform", NULL);
+            Inkscape::XML::Node *arrow_data = arrow->firstChild();
+            if (arrow_data) {
+                SPCSSAttr *css = sp_repr_css_attr_new();
+                sp_repr_css_set_property (css, "fill","#000000");
+                sp_repr_css_set_property (css, "stroke","none");
+                arrow_data->setAttribute("transform", NULL);
+                sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
+                Glib::ustring css_str;
+                sp_repr_css_write_string(css,css_str);
+                arrow_data->setAttribute("style", css_str.c_str());
+            }
+        }
+    } else {
+        arrow = xml_doc->createElement("svg:marker");
+        arrow->setAttribute("id", mode);
+        arrow->setAttribute("inkscape:stockid", mode);
+        arrow->setAttribute("orient", "auto");
+        arrow->setAttribute("refX", "0.0");
+        arrow->setAttribute("refY", "0.0");
+        arrow->setAttribute("style", "overflow:visible");
+        arrow->setAttribute("sodipodi:insensitive", "true");
+        /* Create <path> */
+        Inkscape::XML::Node *arrow_path = xml_doc->createElement("svg:path");
+        if (std::strcmp(mode, "ArrowDIN-start") == 0) {
+            arrow_path->setAttribute("d", "M -8,0 8,-2.11 8,2.11 z");
+        } else if (std::strcmp(mode, "ArrowDIN-end") == 0) {
+            arrow_path->setAttribute("d", "M 8,0 -8,2.11 -8,-2.11 z");
+        } else if (std::strcmp(mode, "ArrowDINout-start") == 0) {
+            arrow_path->setAttribute("d", "M 0,0 -16,2.11 -16,0.5 -26,0.5 -26,-0.5 -16,-0.5 -16,-2.11 z");
+        } else {
+            arrow_path->setAttribute("d", "M 0,0 16,2.11 16,0.5 26,0.5 26,-0.5 16,-0.5 16,-2.11 z");
+        }
+        
+        arrow_path->setAttribute("id", Glib::ustring(mode).append("_path").c_str());
+        SPCSSAttr *css = sp_repr_css_attr_new();
+        sp_repr_css_set_property (css, "fill","#000000");
+        sp_repr_css_set_property (css, "stroke","none");
+        sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
+        Glib::ustring css_str;
+        sp_repr_css_write_string(css,css_str);
+        arrow_path->setAttribute("style", css_str.c_str());
+        arrow->addChild(arrow_path, NULL);
+        Inkscape::GC::release(arrow_path);
+        elemref = SP_OBJECT(document->getDefs()->appendChildRepr(arrow));
+        Inkscape::GC::release(arrow);
+    }
+    elements.push_back(mode);
+}
+
+void
+LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove, bool valid)
+{
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    Inkscape::XML::Document *xml_doc = document->getReprDoc();
+    Inkscape::XML::Node *rtext = NULL;
+    double doc_w = document->getRoot()->width.value;
+    Geom::Scale scale = document->getDocumentScale();
+    SPNamedView *nv = sp_document_namedview(document, NULL);
+    Glib::ustring display_unit = nv->display_units->abbr;
+    if (display_unit.empty()) {
+        display_unit = "px";
+    }
+    //only check constrain viewbox on X
+    doc_scale = Inkscape::Util::Quantity::convert( scale[Geom::X], "px", nv->display_units );
+    if( doc_scale > 0 ) {
+        doc_scale= 1.0/doc_scale;
+    } else {
+        doc_scale = 1.0;
+    }
+    const char * id = g_strdup(Glib::ustring("text-on-").append(this->getRepr()->attribute("id")).c_str());
+    SPObject *elemref = NULL;
+    Inkscape::XML::Node *rtspan = NULL;
+    if (elemref = document->getObjectById(id)) {
+        if (remove) {
+            elemref->deleteObject();
+            return;
+        }
+        pos = pos - Point::polar(angle, text_right_left);
+        rtext = elemref->getRepr();
+        sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
+        sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
+        rtext->setAttribute("sodipodi:insensitive", "true");
+        rtext->setAttribute("transform", NULL);
+    } else {
+        if (remove) {
+            return;
+        }
+        rtext = xml_doc->createElement("svg:text");
+        rtext->setAttribute("xml:space", "preserve");
+        rtext->setAttribute("id", id);
+        rtext->setAttribute("sodipodi:insensitive", "true");
+        pos = pos - Point::polar(angle, text_right_left);
+        sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
+        sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
+        rtspan = xml_doc->createElement("svg:tspan");
+        rtspan->setAttribute("sodipodi:role", "line");
+    }
+    const char * transform;
+    Geom::Affine affine = Geom::Affine(Geom::Translate(pos).inverse());
+    angle = std::fmod(angle, 2*M_PI);
+    if (angle < 0) angle += 2*M_PI;
+    if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
+        angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
+        if (angle < 0) angle += 2*M_PI;
+    }
+    affine *= Geom::Rotate(angle);
+    affine *= Geom::Translate(pos);
+    if (rotate_anotation) {
+        transform = sp_svg_transform_write(affine);
+    } else {
+        transform = NULL;
+    }
+    rtext->setAttribute("transform", transform);
+    SPCSSAttr *css = sp_repr_css_attr_new();
+    sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
+    Inkscape::FontLister *fontlister = Inkscape::FontLister::get_instance();
+    fontlister->fill_css(css, Glib::ustring(fontbutton.param_getSVGValue()));
+    std::stringstream font_size;
+    font_size.imbue(std::locale::classic());
+    font_size <<  fontsize << "pt";
+    sp_repr_css_set_property (css, "font-size",font_size.str().c_str());
+    sp_repr_css_set_property (css, "line-height","125%");
+    sp_repr_css_set_property (css, "letter-spacing","0");
+    sp_repr_css_set_property (css, "word-spacing", "0");
+    sp_repr_css_set_property (css, "text-align", "center");
+    sp_repr_css_set_property (css, "text-anchor", "middle");
+    sp_repr_css_set_property (css, "fill", "#000000");
+    sp_repr_css_set_property (css, "fill-opacity", "1");
+    sp_repr_css_set_property (css, "stroke", "none");
+    sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
+    Glib::ustring css_str;
+    sp_repr_css_write_string(css,css_str);
+    if (!rtspan) {
+        rtspan = rtext->firstChild();
+    }
+    rtext->setAttribute("style", css_str.c_str());
+    rtspan->setAttribute("style", NULL);
+    rtspan->setAttribute("transform", NULL);
+    sp_repr_css_attr_unref (css);
+    if (!elemref) {
+        rtext->addChild(rtspan, NULL);
+        Inkscape::GC::release(rtspan);
+    }
+    length = Inkscape::Util::Quantity::convert(length / doc_scale, display_unit.c_str(), unit.get_abbreviation());
+    std::stringstream length_str;
+    length_str.precision(precision);
+    length_str.setf(std::ios::fixed, std::ios::floatfield);
+    if (local_locale) {
+        length_str.imbue(std::locale(""));
+    } else {
+        length_str.imbue(std::locale::classic());
+    }
+    length_str << std::fixed << length;
+    Glib::ustring label_value = Glib::ustring(format.param_getSVGValue());
+    size_t s = label_value.find(Glib::ustring("{measure}"),0);
+    if(s < label_value.length()) {
+        label_value.replace(s,s+9,length_str.str());
+    }
+    s = label_value.find(Glib::ustring("{unit}"),0);
+    if(s < label_value.length()) {
+        label_value.replace(s,s+6,unit.get_abbreviation());
+    }
+    if ( !valid ) {
+        label_value = Glib::ustring(_("Non Uniform Scale"));
+    }
+    Inkscape::XML::Node *rstring = NULL;
+    if (!elemref) {
+        rstring = xml_doc->createTextNode(label_value.c_str());
+        rtspan->addChild(rstring, NULL);
+        Inkscape::GC::release(rstring);
+    } else {
+        rstring = rtspan->firstChild();
+        rstring->setContent(label_value.c_str());
+    }
+    if (!elemref) {
+        elemref = sp_lpe_item->parent->appendChildRepr(rtext);
+        Inkscape::GC::release(rtext);
+    } else if (elemref->parent != sp_lpe_item->parent) {
+        Inkscape::XML::Node *old_repr = elemref->getRepr();
+        Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
+        SPObject * elemref_copy = sp_lpe_item->parent->appendChildRepr(copy);
+        Inkscape::GC::release(copy);
+        elemref->deleteObject();
+        copy->setAttribute("id", id);
+        elemref = elemref_copy;
+    }
+    elements.push_back(id);
+    Geom::OptRect bounds = SP_ITEM(elemref)->bounds(SPItem::GEOMETRIC_BBOX);
+    if (bounds) {
+        anotation_width = bounds->width() * 1.4;
+    }
+}
+
+void
+LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, const char * id, bool main, bool overflow, bool remove, bool arrows)
+{
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    Inkscape::XML::Document *xml_doc = document->getReprDoc();
+    SPObject *elemref = NULL;
+    Inkscape::XML::Node *line = NULL;
+    if (!main) {
+        Geom::Ray ray(start, end);
+        Geom::Coord angle = ray.angle();
+        start = start + Point::polar(angle, helpline_distance );
+        end = end + Point::polar(angle, helpline_overlap );
+    }
+    Geom::PathVector line_pathv;
+    if (main && std::abs(text_top_bottom) < fontsize/1.5 && hide_back && !overflow){
+        Geom::Path line_path;
+        double k = 0;
+        if (flip_side) {
+            k = (Geom::distance(start,end)/2.0) + arrow_gap - (anotation_width/2.0);
+        } else {
+            k = (Geom::distance(start,end)/2.0) - arrow_gap - (anotation_width/2.0);
+        }
+        if (Geom::distance(start,end) < anotation_width){
+            return;
+        }
+        Geom::Ray ray(end, start);
+        Geom::Coord angle = ray.angle();
+        line_path.start(start);
+        line_path.appendNew<Geom::LineSegment>(start - Point::polar(angle, k));
+        line_pathv.push_back(line_path);
+        line_path.clear();
+        line_path.start(end + Point::polar(angle, k));
+        line_path.appendNew<Geom::LineSegment>(end);
+        line_pathv.push_back(line_path);
+    } else {
+        Geom::Path line_path;
+        line_path.start(start);
+        line_path.appendNew<Geom::LineSegment>(end);
+        line_pathv.push_back(line_path);
+    }
+    if (elemref = document->getObjectById(id)) {
+        if (remove) {
+            elemref->deleteObject();
+            return;
+        }
+        line = elemref->getRepr();
+       
+        const char * line_str = sp_svg_write_path( line_pathv );
+        line->setAttribute("d" , line_str);
+        line->setAttribute("transform", NULL);
+    } else {
+        if (remove) {
+            return;
+        }
+        line = xml_doc->createElement("svg:path");
+        line->setAttribute("id", id);
+        const char * line_str = sp_svg_write_path( line_pathv );
+        line->setAttribute("d" , line_str);
+    }
+    line->setAttribute("sodipodi:insensitive", "true");
+    line_pathv.clear();
+        
+    Glib::ustring style = Glib::ustring("stroke:#000000;fill:none;");
+    if (overflow && !arrows) {
+        line->setAttribute("inkscape:label", "downline");
+    } else if (main) {
+        line->setAttribute("inkscape:label", "dinline");
+        if (arrows_outside) {
+            style = style + Glib::ustring("marker-start:url(#ArrowDINout-start);marker-end:url(#ArrowDINout-end);");
+        } else {
+            style = style + Glib::ustring("marker-start:url(#ArrowDIN-start);marker-end:url(#ArrowDIN-end);");
+        }
+    } else {
+        line->setAttribute("inkscape:label", "dinhelpline");
+    }
+    std::stringstream stroke_w;
+    stroke_w.imbue(std::locale::classic());
+    if (line_group_05) {
+        double stroke_width = Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
+        stroke_w <<  stroke_width;
+        style = style + Glib::ustring("stroke-width:" + stroke_w.str());
+    } else {
+        double stroke_width = Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
+        stroke_w <<  stroke_width;
+        style = style + Glib::ustring("stroke-width:" + stroke_w.str());
+    }
+    SPCSSAttr *css = sp_repr_css_attr_new();
+    sp_repr_css_attr_add_from_string(css, style.c_str());
+    if (main) {
+        sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
+    } else {
+        sp_repr_css_attr_add_from_string(css, helperlines_format.param_getSVGValue());
+    }
+    Glib::ustring css_str;
+    sp_repr_css_write_string(css,css_str);
+    line->setAttribute("style", css_str.c_str());
+    if (!elemref) {
+        elemref = sp_lpe_item->parent->appendChildRepr(line);
+        Inkscape::GC::release(line);
+    } else if (elemref->parent != sp_lpe_item->parent) {
+        Inkscape::XML::Node *old_repr = elemref->getRepr();
+        Inkscape::XML::Node *copy = old_repr->duplicate(xml_doc);
+        SPObject * elemref_copy = sp_lpe_item->parent->appendChildRepr(copy);
+        Inkscape::GC::release(copy);
+        elemref->deleteObject();
+        copy->setAttribute("id", id);
+    }
+    elements.push_back(id);
+}
+
+void
+LPEMeasureLine::doOnApply(SPLPEItem const* lpeitem)
+{
+    if (!SP_IS_SHAPE(lpeitem)) {
+        g_warning("LPE measure line can only be applied to shapes (not groups).");
+        SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+        item->removeCurrentPathEffect(false);
+    }
+    id_origin.param_setValue(Glib::ustring(lpeitem->getId()));
+    id_origin.write_to_SVG();
+}
+
+void
+LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+    SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
+    sp_lpe_item->parent = dynamic_cast<SPObject *>(splpeitem->parent);
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    Inkscape::XML::Node *root = splpeitem->document->getReprRoot();
+    Inkscape::XML::Node *root_origin = document->getReprRoot();
+    if (root_origin != root) {
+        return;
+    }
+    SPPath *sp_path = dynamic_cast<SPPath *>(splpeitem);
+    if (sp_path) {
+        Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(document->getRoot()));
+        Geom::PathVector pathvector = sp_path->get_original_curve()->get_pathvector();
+        Geom::Affine writed_transform = Geom::identity();
+        sp_svg_transform_read(splpeitem->getAttribute("transform"), &writed_transform );
+        pathvector *= writed_transform;
+        if ((Glib::ustring(format.param_getSVGValue()).empty())) {
+            format.param_setValue(Glib::ustring("{measure}{unit}"));
+            this->upd_params = true;
+        }
+        size_t ncurves = pathvector.curveCount();
+        if (ncurves != (size_t)curve_linked.param_get_max()) {
+            curve_linked.param_set_range(0, ncurves);
+        }
+        Geom::Point start = pathvector.initialPoint();
+        Geom::Point end =  pathvector.finalPoint();
+        if (curve_linked) { //!0 
+            start = pathvector.pointAt(curve_linked -1);
+            end = pathvector.pointAt(curve_linked);
+        }
+        if (Geom::are_near(start, start_stored, 0.01) && 
+            Geom::are_near(end, end_stored, 0.01) &&
+            sp_lpe_item->getCurrentLPE() != this){
+            return;
+        }
+        elements.clear();
+        start_stored = start;
+        end_stored = end;
+        Geom::Point hstart = start;
+        Geom::Point hend = end;
+        bool remove = false;
+        if (Geom::are_near(hstart, hend)) {
+            remove = true;
+        }
+        if (orientation == OM_VERTICAL) {
+            Coord xpos = std::max(hstart[Geom::X],hend[Geom::X]);
+            if (flip_side) {
+                xpos = std::min(hstart[Geom::X],hend[Geom::X]);
+            }
+            hstart[Geom::X] = xpos;
+            hend[Geom::X] = xpos;
+            if (hstart[Geom::Y] > hend[Geom::Y]) {
+                swap(hstart,hend);
+                swap(start,end);
+            }
+            if (Geom::are_near(hstart[Geom::Y], hend[Geom::Y])) {
+                remove = true;
+            }
+        }
+        if (orientation == OM_HORIZONTAL) {
+            Coord ypos = std::max(hstart[Geom::Y],hend[Geom::Y]);
+            if (flip_side) {
+                ypos = std::min(hstart[Geom::Y],hend[Geom::Y]);
+            }
+            hstart[Geom::Y] = ypos;
+            hend[Geom::Y] = ypos;
+            if (hstart[Geom::X] < hend[Geom::X]) {
+                swap(hstart,hend);
+                swap(start,end);
+            }
+            if (Geom::are_near(hstart[Geom::X], hend[Geom::X])) {
+                remove = true;
+            }
+        }
+        double length = Geom::distance(hstart,hend)  * scale;
+        Geom::Point pos = Geom::middle_point(hstart,hend);
+        Geom::Ray ray(hstart,hend);
+        Geom::Coord angle = ray.angle();
+        if (flip_side) {
+            angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
+            if (angle < 0) angle += 2*M_PI;
+        }
+        if (arrows_outside) {
+            createArrowMarker("ArrowDINout-start");
+            createArrowMarker("ArrowDINout-end");
+        } else {
+            createArrowMarker("ArrowDIN-start");
+            createArrowMarker("ArrowDIN-end");
+        }
+        //We get the font size to offset the text to the middle
+        Pango::FontDescription fontdesc(Glib::ustring(fontbutton.param_getSVGValue()));
+        fontsize = fontdesc.get_size()/(double)Pango::SCALE;
+        fontsize *= document->getRoot()->c2p.inverse().expansionX();
+        Geom::Coord angle_cross = std::fmod(angle + rad_from_deg(90), 2*M_PI);
+        if (angle_cross < 0) angle_cross += 2*M_PI;
+        angle = std::fmod(angle, 2*M_PI);
+        if (angle < 0) angle += 2*M_PI;
+        if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
+            pos = pos - Point::polar(angle_cross, (position - text_top_bottom) + fontsize/2.5);
+        } else {
+            pos = pos - Point::polar(angle_cross, (position + text_top_bottom) - fontsize/2.5);
+        }
+        double parents_scale = (affinetransform.expansionX() + affinetransform.expansionY()) / 2.0;
+        if (scale_sensitive) {
+            length *= parents_scale;
+        }
+        if (scale_sensitive && !affinetransform.preservesAngles()) {
+            createTextLabel(pos, length, angle, remove, false);
+        } else {
+            createTextLabel(pos, length, angle, remove, true);
+        }
+        bool overflow = false;
+        const char * downline = g_strdup(Glib::ustring("downline-").append(this->getRepr()->attribute("id")).c_str());
+        if ((anotation_width/2) + std::abs(text_right_left) > Geom::distance(start,end)/2.0) {
+            Geom::Point sstart = end - Point::polar(angle_cross, position);
+            Geom::Point send = end - Point::polar(angle_cross, position);
+            if (text_right_left < 0 && flip_side || text_right_left > 0 && !flip_side) {
+                sstart = start - Point::polar(angle_cross, position);
+                send = start - Point::polar(angle_cross, position);
+            }
+            Geom::Point prog_end = Geom::Point();
+            if (std::abs(text_top_bottom) < fontsize/1.5 && hide_back) { 
+                if (text_right_left > 0 ) {
+                    prog_end = sstart - Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
+                } else {
+                    prog_end = sstart + Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
+                }
+            } else {
+                if (text_right_left > 0 ) {
+                    prog_end = sstart - Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
+                } else {
+                    prog_end = sstart + Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
+                }
+            }
+            overflow = true;
+            createLine(sstart, prog_end, downline, true, overflow, false, false);
+        } else {
+            //erase it
+            createLine(Geom::Point(),Geom::Point(), downline, true, overflow, true, false);
+        }
+        //LINE
+        arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
+        if (line_group_05) {
+            arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
+        }
+        SPCSSAttr *css = sp_repr_css_attr_new();
+        sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
+        setlocale(LC_NUMERIC, std::locale::classic().name().c_str());
+        double width_line =  atof(sp_repr_css_property(css,"stroke-width","-1"));
+        setlocale(LC_NUMERIC, std::locale("").name().c_str());
+        if (width_line > -0.0001) {
+             arrow_gap = 8 * Inkscape::Util::Quantity::convert(width_line/ doc_scale, "mm", display_unit.c_str());
+        }
+        if (flip_side) {
+            arrow_gap *= -1;
+        }
+        hstart = hstart - Point::polar(angle_cross, position);
+        createLine(start, hstart, g_strdup(Glib::ustring("infoline-on-start-").append(this->getRepr()->attribute("id")).c_str()), false, false, remove);
+        hend = hend - Point::polar(angle_cross, position);
+        createLine(end, hend, g_strdup(Glib::ustring("infoline-on-end-").append(this->getRepr()->attribute("id")).c_str()), false, false, remove);
+        if (!arrows_outside) {
+            hstart = hstart + Point::polar(angle, arrow_gap);
+            hend = hend - Point::polar(angle, arrow_gap );
+        }
+        createLine(hstart, hend, g_strdup(Glib::ustring("infoline-").append(this->getRepr()->attribute("id")).c_str()), true, overflow, remove, true);     
+    }
+}
+
+void
+LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
+{
+    processObjects(LPE_VISIBILITY);
+}
+
+void 
+LPEMeasureLine::doOnRemove (SPLPEItem const* /*lpeitem*/)
+{
+    //unset "erase_extra_objects" hook on sp-lpe-item.cpp
+    if (!erase_extra_objects) {
+        processObjects(LPE_TO_OBJECTS);
+        elements.clear();
+        return;
+    }
+    processObjects(LPE_ERASE);
+}
+
+void 
+LPEMeasureLine::processObjects(LpeAction lpe_action)
+{
+    SPDocument * document = SP_ACTIVE_DOCUMENT;
+    for (std::vector<const char *>::iterator el_it = elements.begin(); 
+         el_it != elements.end(); ++el_it) {
+        const char * id = *el_it;
+        if (!id || strlen(id) == 0) {
+            return;
+        }
+        SPObject *elemref = NULL;
+        if (elemref = document->getObjectById(id)) {
+            SPCSSAttr *css;
+            Glib::ustring css_str;
+            switch (lpe_action){
+            case LPE_TO_OBJECTS:
+                elemref->getRepr()->setAttribute("inkscape:path-effect", NULL);
+                elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+                break;
+
+            case LPE_ERASE:
+                if (std::strcmp(elemref->getId(),id_origin.param_getSVGValue()) != 0) {
+                    elemref->deleteObject();
+                }
+                break;
+
+            case LPE_VISIBILITY:
+                css = sp_repr_css_attr_new();
+                sp_repr_css_attr_add_from_string(css, elemref->getRepr()->attribute("style"));
+                if (!this->isVisible() && std::strcmp(elemref->getId(),id_origin.param_getSVGValue()) != 0) {
+                    css->setAttribute("display", "none");
+                } else {
+                    css->setAttribute("display", NULL);
+                }
+                sp_repr_css_write_string(css,css_str);
+                elemref->getRepr()->setAttribute("style", css_str.c_str());
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+    if (lpe_action == LPE_ERASE) {
+        elements.clear();
+    }
+}
+
+Gtk::Widget *LPEMeasureLine::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);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
+    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
+    vbox_expander->set_border_width(0);
+    vbox_expander->set_spacing(2);
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            Glib::ustring *tip = param->param_getTooltip();
+            if (widg) {
+                if (param->param_key != "dimline_format" &&
+                    param->param_key != "helperlines_format" &&
+                    param->param_key != "arrows_format" &&
+                    param->param_key != "anotation_format") {
+                    vbox->pack_start(*widg, true, true, 2);
+                } else {
+                    vbox_expander->pack_start(*widg, true, true, 2);
+                }
+                if (tip) {
+                    widg->set_tooltip_text(*tip);
+                } else {
+                    widg->set_tooltip_text("");
+                    widg->set_has_tooltip(false);
+                }
+            }
+        }
+
+        ++it;
+    }
+    Gtk::Button *save_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Save '*' as default"))));
+    save_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::saveDefault));
+    button1->pack_start(*save_default, true, true, 2);
+    expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show DIM CSS style override"))));
+    expander->add(*vbox_expander);
+    expander->set_expanded(expanded);
+    expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPEMeasureLine::onExpanderChanged) );
+    vbox->pack_start(*expander, true, true, 2);
+    vbox->pack_start(*button1, true, true, 2);
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+void
+LPEMeasureLine::onExpanderChanged()
+{
+    expanded = expander->get_expanded();
+    if(expanded) {
+        expander->set_label (Glib::ustring(_("Hide DIM CSS style override")));
+    } else {
+        expander->set_label (Glib::ustring(_("Show DIM CSS style override")));
+    }
+}
+
+Geom::PathVector
+LPEMeasureLine::doEffect_path(Geom::PathVector const &path_in)
+{
+    return path_in;
+}
+
+void
+LPEMeasureLine::saveDefault()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setString("/live_effects/measure-line/fontbutton", Glib::ustring(fontbutton.param_getSVGValue()));
+    prefs->setDouble("/live_effects/measure-line/scale", scale);
+    prefs->setInt("/live_effects/measure-line/precision", precision);
+    prefs->setDouble("/live_effects/measure-line/position", position);
+    prefs->setDouble("/live_effects/measure-line/text_top_bottom", text_top_bottom);
+    prefs->setDouble("/live_effects/measure-line/helpline_distance", helpline_distance);
+    prefs->setDouble("/live_effects/measure-line/helpline_overlap", helpline_overlap);
+    prefs->setString("/live_effects/measure-line/unit", Glib::ustring(unit.get_abbreviation()));
+    prefs->setString("/live_effects/measure-line/format", Glib::ustring(format.param_getSVGValue()));
+    prefs->setString("/live_effects/measure-line/dimline_format", Glib::ustring(dimline_format.param_getSVGValue()));
+    prefs->setString("/live_effects/measure-line/helperlines_format", Glib::ustring(helperlines_format.param_getSVGValue()));
+    prefs->setString("/live_effects/measure-line/anotation_format", Glib::ustring(anotation_format.param_getSVGValue()));
+    prefs->setString("/live_effects/measure-line/arrows_format", Glib::ustring(arrows_format.param_getSVGValue()));
+    prefs->setBool("/live_effects/measure-line/flip_side", flip_side);
+    prefs->setBool("/live_effects/measure-line/scale_sensitive", scale_sensitive);
+    prefs->setBool("/live_effects/measure-line/local_locale", local_locale);
+    prefs->setBool("/live_effects/measure-line/line_group_05", line_group_05);
+    prefs->setBool("/live_effects/measure-line/rotate_anotation", rotate_anotation);
+    prefs->setBool("/live_effects/measure-line/hide_back", hide_back);
+}
+
+}; //namespace LivePathEffect
+}; /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offset:((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/lpe-measure-line.h b/src/live_effects/lpe-measure-line.h
new file mode 100644
index 000000000..c69921a4d
--- /dev/null
+++ b/src/live_effects/lpe-measure-line.h
@@ -0,0 +1,116 @@
+#ifndef INKSCAPE_LPE_MEASURE_LINE_H
+#define INKSCAPE_LPE_MEASURE_LINE_H
+
+/*
+ * Author(s):
+ *     Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+
+#include <gtkmm/expander.h>
+
+#include "live_effects/parameter/enum.h"
+#include "live_effects/parameter/fontbutton.h"
+#include "live_effects/parameter/text.h"
+#include "live_effects/parameter/unit.h"
+#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/originalpath.h"
+#include <libnrtype/font-lister.h>
+#include <2geom/angle.h>
+#include <2geom/ray.h>
+#include <2geom/point.h>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+enum OrientationMethod {
+    OM_HORIZONTAL,
+    OM_VERTICAL,
+    OM_PARALLEL,
+    OM_END
+};
+
+enum LpeAction {
+    LPE_ERASE = 0,
+    LPE_TO_OBJECTS,
+    LPE_VISIBILITY
+};
+
+class LPEMeasureLine : public Effect {
+public:
+    LPEMeasureLine(LivePathEffectObject *lpeobject);
+    virtual ~LPEMeasureLine();
+    virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+    virtual void doOnApply(SPLPEItem const* lpeitem);
+    virtual void doOnRemove (SPLPEItem const* /*lpeitem*/);
+    virtual void doEffect (SPCurve * curve){}; //stop the chain
+    virtual void doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/);
+    virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
+    void processObjects(LpeAction lpe_action);
+    void createLine(Geom::Point start,Geom::Point end, const char * id, bool main, bool overflow, bool remove, bool arrows = false);
+    void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove, bool valid);
+    void onExpanderChanged();
+    void createArrowMarker(const char * mode);
+    void saveDefault();
+    virtual Gtk::Widget *newWidget();
+private:
+    UnitParam unit;
+    FontButtonParam fontbutton;
+    EnumParam<OrientationMethod> orientation;
+    ScalarParam curve_linked;
+    ScalarParam precision;
+    ScalarParam position;
+    ScalarParam text_top_bottom;
+    ScalarParam text_right_left;
+    ScalarParam helpline_distance;
+    ScalarParam helpline_overlap;
+    ScalarParam scale;
+    TextParam format;
+    TextParam id_origin;
+    BoolParam arrows_outside;
+    BoolParam flip_side;
+    BoolParam scale_sensitive;
+    BoolParam local_locale;
+    BoolParam line_group_05;
+    BoolParam rotate_anotation;
+    BoolParam hide_back;
+    TextParam dimline_format;
+    TextParam helperlines_format;
+    TextParam anotation_format;
+    TextParam arrows_format;
+    Glib::ustring display_unit;
+    bool expanded;
+    Gtk::Expander * expander;
+    double doc_scale;
+    double fontsize;
+    double anotation_width;
+    double arrow_gap;
+    Geom::Point start_stored;
+    Geom::Point end_stored; 
+    std::vector<const char *> elements;
+/*    Geom::Affine affine_over;*/
+    LPEMeasureLine(const LPEMeasureLine &);
+    LPEMeasureLine &operator=(const LPEMeasureLine &);
+
+};
+
+} //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/lpe-mirror_symmetry.cpp b/src/live_effects/lpe-mirror_symmetry.cpp
index 9f3070ff4..61b2b8b5c 100644
--- a/src/live_effects/lpe-mirror_symmetry.cpp
+++ b/src/live_effects/lpe-mirror_symmetry.cpp
@@ -13,68 +13,39 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include <gtkmm.h>
-#include <glibmm/i18n.h>
 
+#include <gtkmm.h>
 #include "live_effects/lpe-mirror_symmetry.h"
-#include <sp-path.h>
 #include <display/curve.h>
 #include <svg/path-string.h>
 #include "helper/geom.h"
-#include <2geom/path.h>
 #include <2geom/path-intersection.h>
-#include <2geom/transforms.h>
-#include <2geom/affine.h>
-#include "knot-holder-entity.h"
-#include "knotholder.h"
-#include "inkscape.h"
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
 
 static const Util::EnumData<ModeType> ModeTypeData[MT_END] = {
-    { MT_V, N_("Vertical Page Center"), "Vertical Page Center, use select tool to move item instead line" },
-    { MT_H, N_("Horizontal Page Center"), "Horizontal Page Center, use select tool to move item instead line" },
-    { MT_FREE, N_("Free from reflection line"), "Free from path" },
-    { MT_X, N_("X from middle knot"), "X from middle knot" },
-    { MT_Y, N_("Y from middle knot"), "Y from middle knot" }
+    { MT_V, N_("Vertical Page Center"), "vertical" },
+    { MT_H, N_("Horizontal Page Center"), "horizontal" },
+    { MT_FREE, N_("Free from reflection line"), "free" },
+    { MT_X, N_("X from middle knot"), "X" },
+    { MT_Y, N_("Y from middle knot"), "Y" }
 };
 static const Util::EnumDataConverter<ModeType>
 MTConverter(ModeTypeData, MT_END);
 
-namespace MS {
-
-class KnotHolderEntityCenterMirrorSymmetry : public LPEKnotHolderEntity {
-public:
-    KnotHolderEntityCenterMirrorSymmetry(LPEMirrorSymmetry *effect) : LPEKnotHolderEntity(effect){};
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
-    virtual Geom::Point knot_get() const;
-};
-
-class KnotHolderEntityStartMirrorSymmetry : public LPEKnotHolderEntity {
-public:
-    KnotHolderEntityStartMirrorSymmetry(LPEMirrorSymmetry *effect) : LPEKnotHolderEntity(effect){};
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
-    virtual Geom::Point knot_get() const;
-};
-
-class KnotHolderEntityEndMirrorSymmetry : public LPEKnotHolderEntity {
-public:
-    KnotHolderEntityEndMirrorSymmetry(LPEMirrorSymmetry *effect) : LPEKnotHolderEntity(effect){};
-    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
-    virtual Geom::Point knot_get() const;
-};
-
-} // namespace MS
-
 LPEMirrorSymmetry::LPEMirrorSymmetry(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     mode(_("Mode"), _("Symmetry move mode"), "mode", MTConverter, &wr, this, MT_FREE),
-    discard_orig_path(_("Discard original path?"), _("Check this to only keep the mirrored part of the path"), "discard_orig_path", &wr, this, false),
+    discard_orig_path(_("Discard original path"), _("Check this to only keep the mirrored part of the path"), "discard_orig_path", &wr, this, false),
     fuse_paths(_("Fuse paths"), _("Fuse original and the reflection into a single path"), "fuse_paths", &wr, this, false),
     oposite_fuse(_("Opposite fuse"), _("Picks the other side of the mirror as the original"), "oposite_fuse", &wr, this, false),
-    start_point(_("Start mirror line"), _("Start mirror line"), "start_point", &wr, this, "Adjust the start of mirroring"),
-    end_point(_("End mirror line"), _("End mirror line"), "end_point", &wr, this, "Adjust end of mirroring")
+    start_point(_("Start mirror line"), _("Start mirror line"), "start_point", &wr, this, _("Adjust start of mirroring")),
+    end_point(_("End mirror line"), _("End mirror line"), "end_point", &wr, this, _("Adjust end of mirroring")),
+    center_point(_("Center mirror line"), _("Center mirror line"), "center_point", &wr, this, _("Adjust center of mirroring"))
 {
     show_orig_path = true;
     registerParameter(&mode);
@@ -83,6 +54,8 @@ LPEMirrorSymmetry::LPEMirrorSymmetry(LivePathEffectObject *lpeobject) :
     registerParameter( &oposite_fuse);
     registerParameter( &start_point);
     registerParameter( &end_point);
+    registerParameter( &center_point);
+    previous_center = Geom::Point(0,0);
     apply_to_clippath_and_mask = true;
 }
 
@@ -90,12 +63,47 @@ LPEMirrorSymmetry::~LPEMirrorSymmetry()
 {
 }
 
-void
+Gtk::Widget * LPEMirrorSymmetry::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);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            Glib::ustring *tip = param->param_getTooltip();
+            if (widg) {
+                if (param->param_key != "center_point") {
+                    vbox->pack_start(*widg, true, true, 2);
+                    if (tip) {
+                        widg->set_tooltip_text(*tip);
+                    } else {
+                        widg->set_tooltip_text("");
+                        widg->set_has_tooltip(false);
+                    }
+                }
+            }
+        }
+
+        ++it;
+    }
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
 
+void
 LPEMirrorSymmetry::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     using namespace Geom;
-
+    original_bbox(lpeitem);
+    //center_point->param_set_liveupdate(false);
     Point point_a(boundingbox_X.max(), boundingbox_Y.min());
     Point point_b(boundingbox_X.max(), boundingbox_Y.max());
     Point point_c(boundingbox_X.max(), boundingbox_Y.middle());
@@ -107,52 +115,75 @@ LPEMirrorSymmetry::doBeforeEffect (SPLPEItem const* lpeitem)
         point_a = Geom::Point(center_point[X],boundingbox_Y.min());
         point_b = Geom::Point(center_point[X],boundingbox_Y.max());
     }
-    line_separation.setPoints(point_a, point_b);
+    if ((Geom::Point)start_point == (Geom::Point)end_point) {
+        start_point.param_setValue(point_a, true);
+        end_point.param_setValue(point_b, true);
+        previous_center = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
+        center_point.param_setValue(previous_center, true);
+        return;
+    }
     if ( mode == MT_X || mode == MT_Y ) {
-        start_point.param_setValue(point_a);
-        end_point.param_setValue(point_b);
-        center_point = Geom::middle_point(point_a, point_b);
+        if (!are_near(previous_center, (Geom::Point)center_point, 0.01)) {
+            center_point.param_setValue(Geom::middle_point(point_a, point_b), true);
+            end_point.param_setValue(point_b, true);
+            start_point.param_setValue(point_a, true);
+        } else {
+            if ( mode == MT_X ) {
+                if (!are_near(start_point[X], point_a[X], 0.01)) {
+                    start_point.param_setValue(point_a, true);
+                }
+                if (!are_near(end_point[X], point_b[X], 0.01)) {
+                    end_point.param_setValue(point_b, true);
+                }
+            } else {  //MT_Y
+                if (!are_near(start_point[Y], point_a[Y], 0.01)) {
+                    start_point.param_setValue(point_a, true);
+                }
+                if (!are_near(end_point[Y], point_b[Y], 0.01)) {
+                    end_point.param_setValue(point_b, true);
+                }
+            }
+        }
     } else if ( mode == MT_FREE) {
-        if(!are_near(previous_center,center_point, 0.01)) {
-            Geom::Point trans = center_point - previous_center;
-            start_point.param_setValue(start_point * trans);
-            end_point.param_setValue(end_point * trans);
-            line_separation.setPoints(start_point, end_point);
+        if (are_near(previous_center, (Geom::Point)center_point, 0.01)) {
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
         } else {
-            center_point = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
-            line_separation.setPoints(start_point, end_point);
+            Geom::Point trans = center_point - Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
+            start_point.param_setValue(start_point * trans, true);
+            end_point.param_setValue(end_point * trans, true);
         }
     } else if ( mode == MT_V){
-        if(SP_ACTIVE_DESKTOP){
-            SPDocument * doc = SP_ACTIVE_DESKTOP->getDocument();
-            Geom::Rect view_box_rect = doc->getViewBox();
-            Geom::Point sp = Geom::Point(view_box_rect.width()/2.0, 0);
-            sp *= i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(SP_ACTIVE_DESKTOP->currentLayer()->parent)) .inverse();
-            start_point.param_setValue(sp);
-            Geom::Point ep = Geom::Point(view_box_rect.width()/2.0, view_box_rect.height());
-            ep *= i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(SP_ACTIVE_DESKTOP->currentLayer()->parent)) .inverse();
-            end_point.param_setValue(ep);
-            center_point = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
-            line_separation.setPoints(start_point, end_point);
-        }
+        SPDocument * document = SP_ACTIVE_DOCUMENT;
+        Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
+        Geom::Point sp = Geom::Point(document->getWidth().value("px")/2.0, 0) * transform;
+        start_point.param_setValue(sp, true);
+        Geom::Point ep = Geom::Point(document->getWidth().value("px")/2.0, document->getHeight().value("px")) * transform;
+        end_point.param_setValue(ep, true);
+        center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
     } else { //horizontal page
-        if(SP_ACTIVE_DESKTOP){
-            SPDocument * doc = SP_ACTIVE_DESKTOP->getDocument();
-            Geom::Rect view_box_rect = doc->getViewBox();
-            Geom::Point sp = Geom::Point(0, view_box_rect.height()/2.0);
-            sp *= i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(SP_ACTIVE_DESKTOP->currentLayer()->parent)) .inverse();
-            start_point.param_setValue(sp);
-            Geom::Point ep = Geom::Point(view_box_rect.width(), view_box_rect.height()/2.0);
-            ep *= i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(SP_ACTIVE_DESKTOP->currentLayer()->parent)) .inverse();
-            end_point.param_setValue(ep);
-            center_point = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
-            line_separation.setPoints(start_point, end_point);
-        }
+        SPDocument * document = SP_ACTIVE_DOCUMENT;
+        Geom::Affine transform = i2anc_affine(SP_OBJECT(lpeitem), NULL).inverse();
+        Geom::Point sp = Geom::Point(0, document->getHeight().value("px")/2.0) * transform;
+        start_point.param_setValue(sp, true);
+        Geom::Point ep = Geom::Point(document->getWidth().value("px"), document->getHeight().value("px")/2.0) * transform;
+        end_point.param_setValue(ep, true);
+        center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point), true);
     }
     previous_center = center_point;
 }
 
 void
+LPEMirrorSymmetry::transform_multiply(Geom::Affine const& postmul, bool set)
+{
+    // cycle through all parameters. Most parameters will not need transformation, but path and point params do.
+    for (std::vector<Parameter *>::iterator it = param_vector.begin(); it != param_vector.end(); ++it) {
+        Parameter * param = *it;
+        param->param_transform_multiply(postmul, set);
+    }
+    previous_center = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
+}
+
+void
 LPEMirrorSymmetry::doOnApply (SPLPEItem const* lpeitem)
 {
     using namespace Geom;
@@ -162,11 +193,11 @@ LPEMirrorSymmetry::doOnApply (SPLPEItem const* lpeitem)
     Point point_a(boundingbox_X.max(), boundingbox_Y.min());
     Point point_b(boundingbox_X.max(), boundingbox_Y.max());
     Point point_c(boundingbox_X.max(), boundingbox_Y.middle());
-    start_point.param_setValue(point_a);
+    start_point.param_setValue(point_a, true);
     start_point.param_update_default(point_a);
-    end_point.param_setValue(point_b);
+    end_point.param_setValue(point_b, true);
     end_point.param_update_default(point_b);
-    center_point = point_c;
+    center_point.param_setValue(point_c, true);
     previous_center = center_point;
 }
 
@@ -181,21 +212,8 @@ LPEMirrorSymmetry::doEffect_path (Geom::PathVector const & path_in)
         path_out = pathv_to_linear_and_cubic_beziers(path_in);
     }
 
-    Geom::Point point_a(line_separation.initialPoint());
-    Geom::Point point_b(line_separation.finalPoint());
-
-    Geom::Translate m1(point_a[0], point_a[1]);
-    double hyp = Geom::distance(point_a, point_b);
-    double c = (point_b[0] - point_a[0]) / hyp; // cos(alpha)
-    double s = (point_b[1] - point_a[1]) / hyp; // sin(alpha)
-
-    Geom::Affine m2(c, -s, s, c, 0.0, 0.0);
-    Geom::Scale sca(1.0, -1.0);
-
-    Geom::Affine m = m1.inverse() * m2;
-    m = m * sca;
-    m = m * m2.inverse();
-    m = m * m1;
+    Geom::Line line_separation((Geom::Point)start_point, (Geom::Point)end_point);
+    Geom::Affine m = Geom::reflection (line_separation.vector(), (Geom::Point)start_point);
 
     if (fuse_paths && !discard_orig_path) {
         for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
@@ -300,8 +318,8 @@ LPEMirrorSymmetry::doEffect_path (Geom::PathVector const & path_in)
     }
 
     if (!fuse_paths || discard_orig_path) {
-        for (int i = 0; i < static_cast<int>(path_in.size()); ++i) {
-            path_out.push_back(path_in[i] * m);
+        for (size_t i = 0; i < original_pathv.size(); ++i) {
+            path_out.push_back(original_pathv[i] * m);
         }
     }
 
@@ -323,44 +341,6 @@ LPEMirrorSymmetry::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector
     hp_vec.push_back(helper);
 }
 
-void
-LPEMirrorSymmetry::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
-{
-    SPKnotShapeType knot_shape =  SP_KNOT_SHAPE_CIRCLE;
-    SPKnotModeType knot_mode = SP_KNOT_MODE_XOR;
-    guint32 knot_color = 0x0000ff00;
-    {
-        KnotHolderEntity *c = new MS::KnotHolderEntityCenterMirrorSymmetry(this);
-        c->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the center"), knot_shape, knot_mode, knot_color );
-        knotholder->add(c);
-    }
-};
-
-namespace MS {
-
-using namespace Geom;
-
-void
-KnotHolderEntityCenterMirrorSymmetry::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
-{
-    LPEMirrorSymmetry* lpe = dynamic_cast<LPEMirrorSymmetry *>(_effect);
-    Geom::Point const s = snap_knot_position(p, state);
-    lpe->center_point = s;
-
-    // FIXME: this should not directly ask for updating the item. It should write to SVG, which triggers updating.
-    sp_lpe_item_update_patheffect (SP_LPE_ITEM(item), false, true);
-}
-
-Geom::Point
-KnotHolderEntityCenterMirrorSymmetry::knot_get() const
-{
-    LPEMirrorSymmetry const *lpe = dynamic_cast<LPEMirrorSymmetry const*>(_effect);
-    return lpe->center_point;
-}
-
-} // namespace CR
-
 } //namespace LivePathEffect
 } /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-mirror_symmetry.h b/src/live_effects/lpe-mirror_symmetry.h
index 3a244cb7e..b4967173a 100644
--- a/src/live_effects/lpe-mirror_symmetry.h
+++ b/src/live_effects/lpe-mirror_symmetry.h
@@ -26,11 +26,6 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
-namespace MS {
-// we need a separate namespace to avoid clashes with LPEPerpBisector
-class KnotHolderEntityCenterMirrorSymmetry;
-}
-
 enum ModeType {
     MT_V,
     MT_H,
@@ -46,10 +41,9 @@ public:
     virtual ~LPEMirrorSymmetry();
     virtual void doOnApply (SPLPEItem const* lpeitem);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+    virtual void transform_multiply(Geom::Affine const& postmul, bool set);
     virtual Geom::PathVector doEffect_path (Geom::PathVector const & path_in);
-    /* the knotholder entity classes must be declared friends */
-    friend class MS::KnotHolderEntityCenterMirrorSymmetry;
-    void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    virtual Gtk::Widget * newWidget();
 
 protected:
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
@@ -61,9 +55,8 @@ private:
     BoolParam oposite_fuse;
     PointParam start_point;
     PointParam end_point;
-    Geom::Line line_separation;
+    PointParam center_point;
     Geom::Point previous_center;
-    Geom::Point center_point;
 
     LPEMirrorSymmetry(const LPEMirrorSymmetry&);
     LPEMirrorSymmetry& operator=(const LPEMirrorSymmetry&);
diff --git a/src/live_effects/lpe-offset.cpp b/src/live_effects/lpe-offset.cpp
index d611b88a1..057f404e0 100644
--- a/src/live_effects/lpe-offset.cpp
+++ b/src/live_effects/lpe-offset.cpp
@@ -11,17 +11,12 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-offset.h"
 #include "sp-shape.h"
 #include "display/curve.h"
-
-#include <2geom/path.h>
-#include <2geom/piecewise.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/elliptical-arc.h>
-#include <2geom/transforms.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-parallel.cpp b/src/live_effects/lpe-parallel.cpp
index 23cd5e2e7..276749c43 100644
--- a/src/live_effects/lpe-parallel.cpp
+++ b/src/live_effects/lpe-parallel.cpp
@@ -11,18 +11,15 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-parallel.h"
 #include "sp-shape.h"
 #include "display/curve.h"
 
-#include <2geom/path.h>
-#include <2geom/transforms.h>
-
-#include "knot-holder-entity.h"
 #include "knotholder.h"
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 
diff --git a/src/live_effects/lpe-path_length.cpp b/src/live_effects/lpe-path_length.cpp
index 4ca380c15..a06dbde98 100644
--- a/src/live_effects/lpe-path_length.cpp
+++ b/src/live_effects/lpe-path_length.cpp
@@ -11,12 +11,10 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-path_length.h"
 #include "util/units.h"
-
-#include "2geom/sbasis-geometric.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -39,12 +37,6 @@ LPEPathLength::~LPEPathLength()
 
 }
 
-void
-LPEPathLength::hideCanvasText() {
-    // this is only used in sp-lpe-item.cpp to hide the canvas text when the effect is invisible
-    info_text.param_setValue("");
-}
-
 Geom::Piecewise<Geom::D2<Geom::SBasis> >
 LPEPathLength::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
 {
@@ -71,7 +63,9 @@ LPEPathLength::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & p
         //g_print ("Area is zero\n");
     }
     //g_print ("Area: %f\n", area);
-
+    if (!this->isVisible()) {
+        info_text.param_setValue("");
+    }
     return pwd2_in;
 }
 
diff --git a/src/live_effects/lpe-path_length.h b/src/live_effects/lpe-path_length.h
index e108e770a..14d093c09 100644
--- a/src/live_effects/lpe-path_length.h
+++ b/src/live_effects/lpe-path_length.h
@@ -29,8 +29,6 @@ public:
 
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
 
-    void hideCanvasText();
-
 private:
     LPEPathLength(const LPEPathLength&);
     LPEPathLength& operator=(const LPEPathLength&);
diff --git a/src/live_effects/lpe-patternalongpath.cpp b/src/live_effects/lpe-patternalongpath.cpp
index 911c410f9..966e9020e 100644
--- a/src/live_effects/lpe-patternalongpath.cpp
+++ b/src/live_effects/lpe-patternalongpath.cpp
@@ -6,22 +6,16 @@
 
 #include "live_effects/lpe-patternalongpath.h"
 #include "live_effects/lpeobject.h"
-#include "sp-shape.h"
 #include "display/curve.h"
-#include "svg/svg.h"
-#include "ui/widget/scalar.h"
 
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
 
-#include "knot-holder-entity.h"
 #include "knotholder.h"
-
+#include <cmath>
 #include <algorithm>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 using std::vector;
 
 
@@ -70,7 +64,7 @@ static const Util::EnumDataConverter<PAPCopyType> PAPCopyTypeConverter(PAPCopyTy
 LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     pattern(_("Pattern source:"), _("Path to put along the skeleton path"), "pattern", &wr, this, "M0,0 L1,0"),
-    original_height(0),
+    original_height(0.0),
     prop_scale(_("_Width:"), _("Width of the pattern"), "prop_scale", &wr, this, 1.0),
     copytype(_("Pattern copies:"), _("How many pattern copies to place along the skeleton path"),
         "copytype", PAPCopyTypeConverter, &wr, this, PAPCT_SINGLE_STRETCHED),
@@ -151,15 +145,15 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
         double xspace  = spacing;
         double noffset = normal_offset;
         double toffset = tang_offset;
-        if (prop_units.get_value() && pattBndsY){
+        if (prop_units.get_value()){
             xspace  *= pattBndsX->extent();
             noffset *= pattBndsY->extent();
             toffset *= pattBndsX->extent();
         }
 
         //Prevent more than 90% overlap...
-        if (xspace < -pattBndsX->extent()*.9) {
-            xspace = -pattBndsX->extent()*.9;
+        if (xspace < -pattBndsX->extent() * 0.9) {
+            xspace = -pattBndsX->extent() * 0.9;
         }
         //TODO: dynamical update of parameter ranges?
         //if (prop_units.get_value()){
@@ -168,7 +162,7 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
         //        spacing.param_set_range(-pattBndsX.extent()*.9, Geom::infinity());
         //    }
 
-        y0+=noffset;
+        y0 += noffset;
 
         std::vector<Geom::Piecewise<Geom::D2<Geom::SBasis> > > paths_in;
         paths_in = split_at_discontinuities(pwd2_in);
@@ -177,11 +171,14 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
             Geom::Piecewise<Geom::D2<Geom::SBasis> > path_i = paths_in[idx];
             Piecewise<SBasis> x = x0;
             Piecewise<SBasis> y = y0;
-            Piecewise<D2<SBasis> > uskeleton = arc_length_parametrization(path_i,2,.1);
-            uskeleton = remove_short_cuts(uskeleton,.01);
+            Piecewise<D2<SBasis> > uskeleton = arc_length_parametrization(path_i,2, 0.1);
+            uskeleton = remove_short_cuts(uskeleton, 0.01);
             Piecewise<D2<SBasis> > n = rot90(derivative(uskeleton));
-            n = force_continuity(remove_short_cuts(n,.1));
-            
+            if (Geom::are_near(pwd2_in[0].at0(),pwd2_in[pwd2_in.size()-1].at1(), 0.01)) {
+                n = force_continuity(remove_short_cuts(n, 0.1), 0.01);
+            } else {
+                n = force_continuity(remove_short_cuts(n, 0.1));
+            }            
             int nbCopies = 0;
             double scaling = 1;
             switch(type) {
@@ -201,13 +198,13 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
                     
                 case PAPCT_REPEATED_STRETCHED:
                     // if uskeleton is closed:
-                    if(path_i.segs.front().at0() == path_i.segs.back().at1()){
-                        nbCopies = static_cast<int>(std::floor((uskeleton.domain().extent() - toffset)/(pattBndsX->extent()+xspace)));
+                    if (are_near(path_i.segs.front().at0(), path_i.segs.back().at1())){
+                        nbCopies = std::max(1, static_cast<int>(std::floor((uskeleton.domain().extent() - toffset)/(pattBndsX->extent()+xspace))));
                         pattBndsX = Interval(pattBndsX->min(),pattBndsX->max()+xspace);
                         scaling = (uskeleton.domain().extent() - toffset)/(((double)nbCopies)*pattBndsX->extent());
                         // if not closed: no space at the end
                     }else{
-                        nbCopies = static_cast<int>(std::floor((uskeleton.domain().extent() - toffset + xspace)/(pattBndsX->extent()+xspace)));
+                        nbCopies = std::max(1, static_cast<int>(std::floor((uskeleton.domain().extent() - toffset + xspace)/(pattBndsX->extent()+xspace))));
                         pattBndsX = Interval(pattBndsX->min(),pattBndsX->max()+xspace);
                         scaling = (uskeleton.domain().extent() - toffset)/(((double)nbCopies)*pattBndsX->extent() - xspace);
                     }
@@ -217,18 +214,18 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
                     return pwd2_in;
             };
             
+            //Ceil to 6 decimals
+            scaling = ceil(scaling * 1000000) / 1000000;
             double pattWidth = pattBndsX->extent() * scaling;
             
-            if (scaling != 1.0) {
-                x*=scaling;
-            }
+            x *= scaling;
             if ( scale_y_rel.get_value() ) {
-                y*=(scaling*prop_scale);
+                y *= prop_scale * scaling;
             } else {
-                if (prop_scale != 1.0) y *= prop_scale;
+                y *= prop_scale;
             }
             x += toffset;
-            
+
             double offs = 0;
             for (int i=0; i<nbCopies; i++){
                 if (fuse_tolerance > 0){        
@@ -241,7 +238,7 @@ LPEPatternAlongPath::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > con
                 offs+=pattWidth;
             }
         }
-        if (fuse_tolerance > 0){        
+        if (fuse_tolerance > 0){
             pre_output = fuse_nearby_ends(pre_output, fuse_tolerance);
             for (unsigned i=0; i<pre_output.size(); i++){
                 output.concat(pre_output[i]);
@@ -264,11 +261,12 @@ LPEPatternAlongPath::transform_multiply(Geom::Affine const& postmul, bool set)
     bool transform_stroke = prefs ? prefs->getBool("/options/transform/stroke", true) : true;
     if (transform_stroke && !scale_y_rel) {
         prop_scale.param_set_value(prop_scale * ((postmul.expansionX() + postmul.expansionY()) / 2));
-    } 	
+        prop_scale.write_to_SVG();
+    }
     if (postmul.isTranslation()) {
         pattern.param_transform_multiply(postmul, set);
+        pattern.write_to_SVG();
     }
-    sp_lpe_item_update_patheffect (sp_lpe_item, false, true);
 }
 
 void
@@ -279,10 +277,10 @@ LPEPatternAlongPath::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vect
 
 
 void 
-LPEPatternAlongPath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+LPEPatternAlongPath::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     KnotHolderEntity *e = new WPAP::KnotHolderEntityWidthPatternAlongPath(this);
-    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
+    e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Change the width"), SP_KNOT_SHAPE_CIRCLE);
     knotholder->add(e);
 }
 
diff --git a/src/live_effects/lpe-patternalongpath.h b/src/live_effects/lpe-patternalongpath.h
index 3d7fc02bc..c34a9a15d 100644
--- a/src/live_effects/lpe-patternalongpath.h
+++ b/src/live_effects/lpe-patternalongpath.h
@@ -43,7 +43,7 @@ public:
 
     void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
     
-    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPItem * item);
 
     PathParam  pattern;
 
diff --git a/src/live_effects/lpe-perp_bisector.cpp b/src/live_effects/lpe-perp_bisector.cpp
index 660318c57..bce22250a 100644
--- a/src/live_effects/lpe-perp_bisector.cpp
+++ b/src/live_effects/lpe-perp_bisector.cpp
@@ -11,19 +11,16 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-perp_bisector.h"
 #include "display/curve.h"
 #include "sp-path.h"
 #include "line-geometry.h"
-#include "sp-lpe-item.h"
-#include <2geom/path.h>
 
-#include "knot-holder-entity.h"
 #include "knotholder.h"
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 namespace PB {
diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp
index ae951dfc9..18b5b724d 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -18,9 +18,11 @@
 #include "live_effects/lpe-perspective-envelope.h"
 #include "helper/geom.h"
 #include "display/curve.h"
-#include "svg/svg.h"
 #include <gsl/gsl_linalg.h>
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 using namespace Geom;
 
 namespace Inkscape {
@@ -32,8 +34,8 @@ enum DeformationType {
 };
 
 static const Util::EnumData<unsigned> DeformationTypeData[] = {
-    {DEFORMATION_PERSPECTIVE          , N_("Perspective"), "Perspective"},
-    {DEFORMATION_ENVELOPE          , N_("Envelope deformation"), "Envelope deformation"}
+    {DEFORMATION_PERSPECTIVE          , N_("Perspective"), "perspective"},
+    {DEFORMATION_ENVELOPE          , N_("Envelope deformation"), "envelope_deformation"}
 };
 
 static const Util::EnumDataConverter<unsigned> DeformationTypeConverter(DeformationTypeData, sizeof(DeformationTypeData)/sizeof(*DeformationTypeData));
@@ -377,7 +379,7 @@ LPEPerspectiveEnvelope::newWidget()
                         hbox_down_handles->pack_start(*widg, true, true, 2);
                     }
                     if (tip) {
-                        widg->set_tooltip_text(*tip);
+                        widg->set_tooltip_markup(*tip);
                     } else {
                         widg->set_tooltip_text("");
                         widg->set_has_tooltip(false);
@@ -406,7 +408,8 @@ LPEPerspectiveEnvelope::newWidget()
     vbox->pack_start(*hbox_middle, false, true, 2);
     vbox->pack_start(*hbox_down_handles, true, true, 2);
     Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
-    Gtk::Button* reset_button = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR));
+    Gtk::Button* reset_button = Gtk::manage(new Gtk::Button(_("_Clear"), true));
+    reset_button->set_image_from_icon_name("edit-clear");
     reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid));
     reset_button->set_size_request(140,30);
     vbox->pack_start(*hbox, true,true,2);
@@ -538,4 +541,4 @@ LPEPerspectiveEnvelope::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::v
   fill-column:99
   End:
 */
-// vim: file_type=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/lpe-perspective_path.cpp b/src/live_effects/lpe-perspective_path.cpp
index c8cdd7912..979b6dea5 100644
--- a/src/live_effects/lpe-perspective_path.cpp
+++ b/src/live_effects/lpe-perspective_path.cpp
@@ -11,22 +11,17 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 #include <gtkmm.h>
-#include <glibmm/i18n.h>
-
 #include "persp3d.h"
 //#include "transf_mat_3x4.h"
-#include "document.h"
 #include "document-private.h"
 #include "live_effects/lpe-perspective_path.h"
 #include "live_effects/lpeobject.h"
-#include "sp-item-group.h"
 #include "knot-holder-entity.h"
 #include "knotholder.h"
-#include "desktop.h"
 #include <util/units.h>
-#include "inkscape.h"
 
-#include <2geom/path.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -107,12 +102,12 @@ void LPEPerspectivePath::refresh(Gtk::Entry* perspective) {
     perspectiveID = perspective->get_text();
     Persp3D *first = 0;
     Persp3D *persp = 0;
-    for ( SPObject *child = this->lpeobj->document->getDefs()->firstChild(); child && !persp; child = child->getNext() ) {
-        if (SP_IS_PERSP3D(child) && first == 0) {
-            first = SP_PERSP3D(child);
+    for (auto& child: lpeobj->document->getDefs()->children) {
+        if (SP_IS_PERSP3D(&child) && first == 0) {
+            first = SP_PERSP3D(&child);
         }
-        if (SP_IS_PERSP3D(child) && strcmp(child->getId(), const_cast<const gchar *>(perspectiveID.c_str())) == 0) {
-            persp = SP_PERSP3D(child);
+        if (SP_IS_PERSP3D(&child) && strcmp(child.getId(), const_cast<const gchar *>(perspectiveID.c_str())) == 0) {
+            persp = SP_PERSP3D(&child);
             break;
         }
     }
@@ -247,9 +242,9 @@ LPEPerspectivePath::newWidget()
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
-void LPEPerspectivePath::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) {
+void LPEPerspectivePath::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
     KnotHolderEntity *e = new PP::KnotHolderEntityOffset(this);
-    e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+    e->create( NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                _("Adjust the origin") );
     knotholder->add(e);
 };
diff --git a/src/live_effects/lpe-perspective_path.h b/src/live_effects/lpe-perspective_path.h
index c4ddf1853..87ee453ff 100644
--- a/src/live_effects/lpe-perspective_path.h
+++ b/src/live_effects/lpe-perspective_path.h
@@ -41,7 +41,7 @@ public:
     virtual Gtk::Widget * newWidget();
     /* the knotholder entity classes must be declared friends */
     friend class PP::KnotHolderEntityOffset;
-    void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
 private:
     // add the parameters for your effect here:
diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp
index 66c8776b5..e9f3975c7 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -13,32 +13,20 @@
 #include "live_effects/lpe-powerstroke.h"
 #include "live_effects/lpe-powerstroke-interpolators.h"
 
-#include "sp-shape.h"
 #include "style.h"
-#include "xml/repr.h"
-#include "sp-paint-server.h"
 #include "svg/svg-color.h"
 #include "desktop-style.h"
 #include "svg/css-ostringstream.h"
 #include "display/curve.h"
 
-#include <2geom/path.h>
-#include <2geom/piecewise.h>
-#include <2geom/sbasis-geometric.h>
-#include <2geom/transforms.h>
-#include <2geom/bezier-utils.h>
 #include <2geom/elliptical-arc.h>
-#include <2geom/sbasis-to-bezier.h>
 #include <2geom/path-sink.h>
 #include <2geom/path-intersection.h>
-#include <2geom/crossing.h>
-#include <2geom/ellipse.h>
 #include <2geom/circle.h>
-#include <2geom/math-utils.h>
 #include "helper/geom.h"
-#include <math.h>
 
-#include "spiro.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Geom {
 // should all be moved to 2geom at some point
@@ -624,11 +612,12 @@ LPEPowerStroke::doEffect_path (Geom::PathVector const & path_in)
     // find time values for which x lies outside path domain
     // and only take portion of x and y that lies within those time values
     std::vector< double > rtsmin = roots (x - pwd2_in.domain().min());
-    std::vector< double > rtsmax = roots (x - pwd2_in.domain().max());
+    std::vector< double > rtsmax = roots (x + pwd2_in.domain().max());
     if ( !rtsmin.empty() && !rtsmax.empty() ) {
         x = portion(x, rtsmin.at(0), rtsmax.at(0));
         y = portion(y, rtsmin.at(0), rtsmax.at(0));
     }
+
     LineJoinType jointype = static_cast<LineJoinType>(linejoin_type.get_value());
 
     Piecewise<D2<SBasis> > pwd2_out   = compose(pwd2_in,x) + y*compose(n,x);
diff --git a/src/live_effects/lpe-recursiveskeleton.cpp b/src/live_effects/lpe-recursiveskeleton.cpp
index ac571d963..aa0db920b 100644
--- a/src/live_effects/lpe-recursiveskeleton.cpp
+++ b/src/live_effects/lpe-recursiveskeleton.cpp
@@ -10,17 +10,12 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-recursiveskeleton.h"
 
-#include <2geom/path.h>
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/piecewise.h>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-rough-hatches.cpp b/src/live_effects/lpe-rough-hatches.cpp
index 76421e0f0..3cc8658ea 100644
--- a/src/live_effects/lpe-rough-hatches.cpp
+++ b/src/live_effects/lpe-rough-hatches.cpp
@@ -13,24 +13,17 @@
  */
 
 #include "ui/widget/scalar.h"
-#include <glibmm/i18n.h>
 #include "live_effects/lpe-rough-hatches.h"
 
 #include "sp-item.h"
 #include "sp-path.h"
-#include "svg/svg.h"
 #include "xml/repr.h"
 
-#include <2geom/path.h>
-#include <2geom/piecewise.h>
-#include <2geom/sbasis.h>
 #include <2geom/sbasis-math.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/affine.h>
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index 105fe2fc4..c6edffd9b 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -14,15 +14,13 @@
  */
 
 #include <gtkmm.h>
-#include "desktop.h"
 #include "live_effects/lpe-roughen.h"
 #include "display/curve.h"
-#include "live_effects/parameter/parameter.h"
 #include <boost/functional/hash.hpp>
 #include "helper/geom.h"
-#include "sp-item-group.h"
+
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
-#include <cmath>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -229,7 +227,7 @@ void LPERoughen::doEffect(SPCurve *curve)
                 nCurve->lineto(curve_it1->finalPoint());
             }
             last_move = Geom::Point(0, 0);
-            double length = curve_it1->length(0.001);
+            double length = curve_it1->length(0.01);
             std::size_t splits = 0;
             if (method == DM_SEGMENTS) {
                 splits = segments;
@@ -354,9 +352,6 @@ SPCurve const * LPERoughen::addNodesAndJitter(Geom::Curve const * A, Geom::Point
             point_a3 = seg1[3] + point_a3;
             ray.setPoints(prev,A->initialPoint());
             point_a1  = A->initialPoint() + Geom::Point::polar(ray.angle(), max_lenght);
-            if(prev == Geom::Point(0,0)){
-                point_a1 = randomize(max_lenght);
-            }
             if(last){
                 Geom::Path b2(point_b3);
                 b2.appendNew<Geom::LineSegment>(point_a3);
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index 44a723c89..bab06022f 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -12,8 +12,8 @@
 #ifndef INKSCAPE_LPE_ROUGHEN_H
 #define INKSCAPE_LPE_ROUGHEN_H
 
-#include "live_effects/parameter/enum.h"
 #include "live_effects/effect.h"
+#include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/parameter.h"
 #include "live_effects/parameter/path.h"
 #include "live_effects/parameter/bool.h"
diff --git a/src/live_effects/lpe-ruler.cpp b/src/live_effects/lpe-ruler.cpp
index 49b5faa2e..60c2a3e1c 100644
--- a/src/live_effects/lpe-ruler.cpp
+++ b/src/live_effects/lpe-ruler.cpp
@@ -12,11 +12,8 @@
  */
 
 #include "live_effects/lpe-ruler.h"
-#include <2geom/piecewise.h>
-#include <2geom/sbasis-geometric.h>
-#include "inkscape.h"
-#include "desktop.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-show_handles.cpp b/src/live_effects/lpe-show_handles.cpp
index 0bc1c4f17..7c298d0e7 100644
--- a/src/live_effects/lpe-show_handles.cpp
+++ b/src/live_effects/lpe-show_handles.cpp
@@ -7,9 +7,7 @@
  */
 
 #include <gtkmm.h>
-#include <glibmm/i18n.h>
 #include "live_effects/lpe-show_handles.h"
-#include "live_effects/parameter/parameter.h"
 #include <2geom/sbasis-to-bezier.h>
 #include <2geom/svg-path-parser.h>
 #include "helper/geom.h"
@@ -17,6 +15,9 @@
 #include "style.h"
 #include "svg/svg.h"
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 
@@ -25,20 +26,17 @@ LPEShowHandles::LPEShowHandles(LivePathEffectObject *lpeobject)
       nodes(_("Show nodes"), _("Show nodes"), "nodes", &wr, this, true),
       handles(_("Show handles"), _("Show handles"), "handles", &wr, this, true),
       original_path(_("Show path"), _("Show path"), "original_path", &wr, this, true),
-      scale_nodes_and_handles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scale_nodes_and_handles", &wr, this, 10),
-      rotate_nodes(_("Rotate nodes"), _("Rotate nodes"), "rotate_nodes", &wr, this, 0)
+      show_center_node(_("Show center of node"), _("Show center of node"), "show_center_node", &wr, this, false),
+      scale_nodes_and_handles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scale_nodes_and_handles", &wr, this, 10)
 {
     registerParameter(&nodes);
     registerParameter(&handles);
     registerParameter(&original_path);
+    registerParameter(&show_center_node);
     registerParameter(&scale_nodes_and_handles);
-    registerParameter(&rotate_nodes);
     scale_nodes_and_handles.param_set_range(0, 500.);
     scale_nodes_and_handles.param_set_increments(1, 1);
     scale_nodes_and_handles.param_set_digits(2);
-    rotate_nodes.param_set_range(0, 365);
-    rotate_nodes.param_set_increments(1, 1);
-    rotate_nodes.param_set_digits(0);
     stroke_width = 1.0;
 }
 
@@ -130,7 +128,11 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
             }
         }
         if(nodes) {
-            drawNode(curve_it1->initialPoint());
+            Geom::NodeType nodetype = Geom::NODE_CUSP;
+            if(path_it->closed()) {
+                nodetype = Geom::get_nodetype(path_it->finalCurve(), *curve_it1);
+            } 
+            drawNode(curve_it1->initialPoint(), nodetype);
         }
         while (curve_it1 != curve_endit) {
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
@@ -146,8 +148,9 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
                     }
                 }
             }
-            if(nodes) {
-                drawNode(curve_it1->finalPoint());
+            if(nodes && (curve_it2 != curve_endit || !path_it->closed())) {
+                Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, *curve_it2);
+                drawNode(curve_it1->finalPoint(), nodetype);
             }
             ++curve_it1;
             if(curve_it2 != curve_endit) {
@@ -158,16 +161,26 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result)
 }
 
 void
-LPEShowHandles::drawNode(Geom::Point p)
+LPEShowHandles::drawNode(Geom::Point p, Geom::NodeType nodetype)
 {
     if(stroke_width * scale_nodes_and_handles > 0.0) {
+        Geom::Rotate rotate = Geom::Rotate(0);
+        if ( nodetype == Geom::NODE_CUSP) {
+            rotate = Geom::Rotate::from_degrees(45);
+        }
         double diameter = stroke_width * scale_nodes_and_handles;
         char const * svgd;
-        svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z";
+        if (show_center_node) {
+            svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z";
+        } else {
+            svgd = "M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z";
+        }
         Geom::PathVector pathv = sp_svg_read_pathv(svgd);
-        pathv *= Geom::Rotate::from_degrees(rotate_nodes) * Geom::Scale(diameter) * Geom::Translate(p);
+        pathv *= rotate * Geom::Scale(diameter) * Geom::Translate(p);
         outline_path.push_back(pathv[0]);
-        outline_path.push_back(pathv[1]);
+        if (show_center_node) {
+            outline_path.push_back(pathv[1]);
+        }
     }
 }
 
diff --git a/src/live_effects/lpe-show_handles.h b/src/live_effects/lpe-show_handles.h
index 34390dd32..c46abd2c2 100644
--- a/src/live_effects/lpe-show_handles.h
+++ b/src/live_effects/lpe-show_handles.h
@@ -8,7 +8,7 @@
 * Copyright (C) Jabier Arraiza Cenoz 2014 <jabier.arraiza@marker.es>
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
+#include "helper/geom-nodetype.h"
 #include "live_effects/effect.h"
 #include "live_effects/lpegroupbbox.h"
 #include "live_effects/parameter/bool.h"
@@ -28,7 +28,7 @@ public:
 
     virtual void generateHelperPath(Geom::PathVector result);
 
-    virtual void drawNode(Geom::Point p);
+    virtual void drawNode(Geom::Point p, Geom::NodeType nodetype);
 
     virtual void drawHandle(Geom::Point p);
 
@@ -43,8 +43,8 @@ private:
     BoolParam nodes;
     BoolParam handles;
     BoolParam original_path;
+    BoolParam show_center_node;
     ScalarParam scale_nodes_and_handles;
-    ScalarParam rotate_nodes;
     double stroke_width;
     static bool alerts_off;
 
diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp
index f807bdc8d..5de9816bb 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -3,24 +3,16 @@
  */
 
 #include <gtkmm.h>
-
 #include "live_effects/lpe-simplify.h"
 #include "display/curve.h"
-#include "live_effects/parameter/parameter.h"
-#include <glibmm/i18n.h>
 #include "helper/geom.h"
-#include "livarot/Path.h"
-#include "splivarot.h"
 #include <2geom/svg-path-parser.h>
-#include "desktop.h"
-#include "inkscape.h"
 #include "svg/svg.h"
 #include "ui/tools/node-tool.h"
-#include <2geom/d2.h>
-#include <2geom/generic-rect.h>
-#include <2geom/interval.h>
 #include "ui/icon-names.h"
-#include "util/units.h"
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -148,11 +140,7 @@ LPESimplify::doEffect(SPCurve *curve)
     Geom::PathVector result = Geom::parse_svg_path(pathliv->svg_dump_path());
     generateHelperPathAndSmooth(result);
     curve->set_pathvector(result);
-    SPDesktop* desktop = SP_ACTIVE_DESKTOP;
-    if(desktop && INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nt = static_cast<Inkscape::UI::Tools::NodeTool*>(desktop->event_context);
-        nt->update_helperpath();
-    }
+    Inkscape::UI::Tools::sp_update_helperpath();
 }
 
 void
diff --git a/src/live_effects/lpe-simplify.h b/src/live_effects/lpe-simplify.h
index 294d77b35..6c407f572 100644
--- a/src/live_effects/lpe-simplify.h
+++ b/src/live_effects/lpe-simplify.h
@@ -6,7 +6,6 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-
 #include "live_effects/effect.h"
 #include "live_effects/parameter/togglebutton.h"
 #include "live_effects/lpegroupbbox.h"
diff --git a/src/live_effects/lpe-skeleton.cpp b/src/live_effects/lpe-skeleton.cpp
index 6e4afbe9b..4fc18cee2 100644
--- a/src/live_effects/lpe-skeleton.cpp
+++ b/src/live_effects/lpe-skeleton.cpp
@@ -20,14 +20,9 @@
 
 #include "live_effects/lpe-skeleton.h"
 
-// You might need to include other 2geom files. You can add them here:
-#include <2geom/path.h>
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
-//#include "knot-holder-entity.h"
-//#include "knotholder.h"
-
 namespace Inkscape {
 namespace LivePathEffect {
 
@@ -102,10 +97,10 @@ public:
 } // namespace Skeleton
 
 void
-LPESkeleton::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) {
+LPESkeleton::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
     {
         KnotHolderEntityMyHandle *e = new KnotHolderEntityMyHandle(this);
-        e->create(  desktop, item, knotholder,
+        e->create( NULL, item, knotholder,
                     _("Text describing what this handle does"),
                     //optional: knot_shape, knot_mode, knot_color);
         knotholder->add(e);
diff --git a/src/live_effects/lpe-skeleton.h b/src/live_effects/lpe-skeleton.h
index 3b45b6978..e633ba5ab 100644
--- a/src/live_effects/lpe-skeleton.h
+++ b/src/live_effects/lpe-skeleton.h
@@ -41,7 +41,7 @@ public:
 
     /* the knotholder entity classes (if any) can be declared friends */
     //friend class Skeleton::KnotHolderEntityMyHandle;
-    //virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    //virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
 private:
     // add the parameters for your effect here:
diff --git a/src/live_effects/lpe-sketch.cpp b/src/live_effects/lpe-sketch.cpp
index 82d343f6e..e01516f2e 100644
--- a/src/live_effects/lpe-sketch.cpp
+++ b/src/live_effects/lpe-sketch.cpp
@@ -13,21 +13,14 @@
 
 #include "live_effects/lpe-sketch.h"
 
-#include <glibmm/i18n.h>
-
 // You might need to include other 2geom files. You can add them here:
-#include <2geom/path.h>
-#include <2geom/sbasis.h>
-#include <2geom/sbasis-geometric.h>
 #include <2geom/sbasis-math.h>
 #include <2geom/bezier-to-sbasis.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/d2.h>
-#include <2geom/sbasis-math.h>
-#include <2geom/piecewise.h>
-#include <2geom/crossing.h>
 #include <2geom/path-intersection.h>
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 
diff --git a/src/live_effects/lpe-spiro.cpp b/src/live_effects/lpe-spiro.cpp
index 0d42596b2..8ea57bee4 100644
--- a/src/live_effects/lpe-spiro.cpp
+++ b/src/live_effects/lpe-spiro.cpp
@@ -7,9 +7,6 @@
 #include "live_effects/lpe-spiro.h"
 
 #include "display/curve.h"
-#include <typeinfo>
-#include <2geom/pathvector.h>
-#include <2geom/affine.h>
 #include <2geom/curves.h>
 #include "helper/geom-nodetype.h"
 #include "helper/geom-curves.h"
@@ -19,8 +16,6 @@
 // For handling un-continuous paths:
 #include "message-stack.h"
 #include "inkscape.h"
-#include "desktop.h"
-
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-tangent_to_curve.cpp b/src/live_effects/lpe-tangent_to_curve.cpp
index 978ab57fb..5f63e1ee9 100644
--- a/src/live_effects/lpe-tangent_to_curve.cpp
+++ b/src/live_effects/lpe-tangent_to_curve.cpp
@@ -13,17 +13,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-tangent_to_curve.h"
 #include "sp-path.h"
 #include "display/curve.h"
 
-#include <2geom/path.h>
-#include <2geom/transforms.h>
-
-#include "knot-holder-entity.h"
 #include "knotholder.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -96,22 +92,22 @@ LPETangentToCurve::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const
 }
 
 void
-LPETangentToCurve::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) {
+LPETangentToCurve::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
     {
         KnotHolderEntity *e = new TtC::KnotHolderEntityAttachPt(this);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+        e->create( NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                    _("Adjust the point of attachment of the tangent") );
         knotholder->add(e);
     }
     {
         KnotHolderEntity *e = new TtC::KnotHolderEntityLeftEnd(this);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+        e->create( NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                     _("Adjust the <b>left</b> end of the tangent") );
         knotholder->add(e);
     }
     {
         KnotHolderEntity *e = new TtC::KnotHolderEntityRightEnd(this);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+        e->create( NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                    _("Adjust the <b>right</b> end of the tangent") );
         knotholder->add(e);
     }
diff --git a/src/live_effects/lpe-tangent_to_curve.h b/src/live_effects/lpe-tangent_to_curve.h
index 8e44c01d1..a6a3c17ca 100644
--- a/src/live_effects/lpe-tangent_to_curve.h
+++ b/src/live_effects/lpe-tangent_to_curve.h
@@ -41,7 +41,7 @@ public:
     friend class TtC::KnotHolderEntityLeftEnd;
     friend class TtC::KnotHolderEntityRightEnd;
     friend class TtC::KnotHolderEntityAttachPt;
-    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPItem * item);
 
 private:
     ScalarParam angle;
diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp
index f2ddd4929..f4a81aa90 100644
--- a/src/live_effects/lpe-taperstroke.cpp
+++ b/src/live_effects/lpe-taperstroke.cpp
@@ -13,26 +13,20 @@
 
 #include "live_effects/lpe-taperstroke.h"
 
-#include <2geom/path.h>
-#include <2geom/path.h>
 #include <2geom/circle.h>
 #include <2geom/sbasis-to-bezier.h>
 
 #include "helper/geom-nodetype.h"
 #include "helper/geom-pathstroke.h"
 #include "display/curve.h"
-#include "sp-shape.h"
 #include "style.h"
-#include "xml/repr.h"
-#include "sp-paint-server.h"
 #include "svg/svg-color.h"
 #include "desktop-style.h"
 #include "svg/css-ostringstream.h"
 #include "svg/svg.h"
 
-#include "knot-holder-entity.h"
 #include "knotholder.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
 template<typename T>
@@ -441,14 +435,14 @@ Piecewise<D2<SBasis> > stretch_along(Piecewise<D2<SBasis> > pwd2_in, Geom::Path
     }
 }
 
-void LPETaperStroke::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+void LPETaperStroke::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     KnotHolderEntity *e = new TpS::KnotHolderEntityAttachBegin(this);
-    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Start point of the taper"), SP_KNOT_SHAPE_CIRCLE);
+    e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("Start point of the taper"), SP_KNOT_SHAPE_CIRCLE);
     knotholder->add(e);
 
     KnotHolderEntity *f = new TpS::KnotHolderEntityAttachEnd(this);
-    f->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("End point of the taper"), SP_KNOT_SHAPE_CIRCLE);
+    f->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _("End point of the taper"), SP_KNOT_SHAPE_CIRCLE);
     knotholder->add(f);
 }
 
diff --git a/src/live_effects/lpe-taperstroke.h b/src/live_effects/lpe-taperstroke.h
index 88604486e..e3ecbb56c 100644
--- a/src/live_effects/lpe-taperstroke.h
+++ b/src/live_effects/lpe-taperstroke.h
@@ -36,7 +36,7 @@ public:
     virtual Geom::PathVector doEffect_path (Geom::PathVector const& path_in);
     Geom::PathVector doEffect_simplePath(Geom::PathVector const& path_in);
 
-    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPDesktop * desktop, SPItem * item);
+    virtual void addKnotHolderEntities(KnotHolder * knotholder, SPItem * item);
 
     friend class TpS::KnotHolderEntityAttachBegin;
     friend class TpS::KnotHolderEntityAttachEnd;
diff --git a/src/live_effects/lpe-test-doEffect-stack.cpp b/src/live_effects/lpe-test-doEffect-stack.cpp
index 2bcd4c136..324893706 100644
--- a/src/live_effects/lpe-test-doEffect-stack.cpp
+++ b/src/live_effects/lpe-test-doEffect-stack.cpp
@@ -4,13 +4,11 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-test-doEffect-stack.h"
 
-#include <2geom/piecewise.h>
-#include <vector>
-#include <cstring>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 using std::memcpy;
 
 namespace Inkscape {
diff --git a/src/live_effects/lpe-text_label.cpp b/src/live_effects/lpe-text_label.cpp
index 602a6897c..709d05e18 100644
--- a/src/live_effects/lpe-text_label.cpp
+++ b/src/live_effects/lpe-text_label.cpp
@@ -11,10 +11,11 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-text_label.h"
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 
diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp
index 3c4ce0708..ef2900775 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -14,15 +14,13 @@
 
 #include "live_effects/lpe-transform_2pts.h"
 #include "display/curve.h"
-#include <2geom/transforms.h>
-#include <2geom/pathvector.h>
-#include "sp-path.h"
 #include "ui/icon-names.h"
 #include "svg/svg.h"
 #include "verbs.h"
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
+
 namespace Inkscape {
 namespace LivePathEffect {
 
@@ -36,7 +34,7 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) :
     flip_vertical(_("Flip vertical"), _("Flip vertical"), "flip_vertical", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
     start(_("Start"), _("Start point"), "start", &wr, this, "Start point"),
     end(_("End"), _("End point"), "end", &wr, this, "End point"),
-    strech(_("Stretch"), _("Stretch the result"), "strech", &wr, this, 1),
+    stretch(_("Stretch"), _("Stretch the result"), "stretch", &wr, this, 1),
     offset(_("Offset"), _("Offset from knots"), "offset", &wr, this, 0),
     first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1),
     last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1),
@@ -54,7 +52,7 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) :
     registerParameter(&first_knot);
     registerParameter(&last_knot);
     registerParameter(&helper_size);
-    registerParameter(&strech);
+    registerParameter(&stretch);
     registerParameter(&offset);
     registerParameter(&start);
     registerParameter(&end);
@@ -75,9 +73,9 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) :
     offset.param_set_range(-999999.0, 999999.0);
     offset.param_set_increments(1, 1);
     offset.param_set_digits(2);
-    strech.param_set_range(0, 999.0);
-    strech.param_set_increments(0.01, 0.01);
-    strech.param_set_digits(4);
+    stretch.param_set_range(0, 999.0);
+    stretch.param_set_increments(0.01, 0.01);
+    stretch.param_set_digits(4);
     apply_to_clippath_and_mask = true;
 }
 
@@ -90,7 +88,6 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem)
 {
     using namespace Geom;
     original_bbox(lpeitem);
-
     point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
     point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
     SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
@@ -382,9 +379,9 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const
         m *= Geom::Scale(-1,1);
         m *= Geom::Rotate(original_angle);
     }
-    if(strech != 1){
+    if(stretch != 1){
         m *= Geom::Rotate(-original_angle);
-        m *= Geom::Scale(1,strech);
+        m *= Geom::Scale(1,stretch);
         m *= Geom::Rotate(original_angle);
     }
     if(elastic) {
diff --git a/src/live_effects/lpe-transform_2pts.h b/src/live_effects/lpe-transform_2pts.h
index c20d56206..0f88e6b00 100644
--- a/src/live_effects/lpe-transform_2pts.h
+++ b/src/live_effects/lpe-transform_2pts.h
@@ -57,7 +57,7 @@ private:
     ToggleButtonParam flip_vertical;
     PointParam start;
     PointParam end;
-    ScalarParam strech;
+    ScalarParam stretch;
     ScalarParam offset;
     ScalarParam first_knot;
     ScalarParam last_knot;
diff --git a/src/live_effects/lpe-vonkoch.cpp b/src/live_effects/lpe-vonkoch.cpp
index 7eda7446e..47e2a1cec 100644
--- a/src/live_effects/lpe-vonkoch.cpp
+++ b/src/live_effects/lpe-vonkoch.cpp
@@ -5,11 +5,9 @@
  */
 
 #include "live_effects/lpe-vonkoch.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
-#include <2geom/transforms.h>
-
 //using std::vector;
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpegroupbbox.cpp b/src/live_effects/lpegroupbbox.cpp
index 2a1b70a6a..3862ebcc8 100644
--- a/src/live_effects/lpegroupbbox.cpp
+++ b/src/live_effects/lpegroupbbox.cpp
@@ -7,8 +7,6 @@
 
 #include "live_effects/lpegroupbbox.h"
 
-#include "sp-item.h"
-
 namespace Inkscape {
 namespace LivePathEffect {
 
diff --git a/src/live_effects/lpeobject-reference.cpp b/src/live_effects/lpeobject-reference.cpp
index d9de6e77f..1940806bd 100644
--- a/src/live_effects/lpeobject-reference.cpp
+++ b/src/live_effects/lpeobject-reference.cpp
@@ -8,7 +8,6 @@
 
 #include <string.h>
 
-#include "enums.h"
 #include "live_effects/lpeobject-reference.h"
 #include "live_effects/lpeobject.h"
 #include "uri.h"
diff --git a/src/live_effects/lpeobject.cpp b/src/live_effects/lpeobject.cpp
index 8e5ae568f..b5b27c984 100644
--- a/src/live_effects/lpeobject.cpp
+++ b/src/live_effects/lpeobject.cpp
@@ -11,13 +11,10 @@
 
 #include "xml/repr.h"
 #include "xml/node-event-vector.h"
-#include "sp-object.h"
 #include "attributes.h"
 #include "document.h"
 #include "document-private.h"
 
-#include <glibmm/i18n.h>
-
 //#define LIVEPATHEFFECT_VERBOSE
 
 static void livepatheffect_on_repr_attr_changed (Inkscape::XML::Node * repr, const gchar *key, const gchar *oldval, const gchar *newval, bool is_interactive, void * data);
diff --git a/src/live_effects/lpeobject.h b/src/live_effects/lpeobject.h
index 2e62707e3..087223947 100644
--- a/src/live_effects/lpeobject.h
+++ b/src/live_effects/lpeobject.h
@@ -38,8 +38,14 @@ public:
 
     /* Note that the returned pointer can be NULL in a valid LivePathEffectObject contained in a valid list of lpeobjects in an lpeitem!
      * So one should always check whether the returned value is NULL or not */
-    Inkscape::LivePathEffect::Effect * get_lpe() { return lpe; };
-    Inkscape::LivePathEffect::Effect const * get_lpe() const { return lpe; };
+    Inkscape::LivePathEffect::Effect * get_lpe() {
+        if(this) return lpe;
+        else return NULL;
+    }
+    Inkscape::LivePathEffect::Effect const * get_lpe() const {
+        if(this) return lpe;
+        else return NULL;
+    };
 
     Inkscape::LivePathEffect::Effect *lpe; // this can be NULL in a valid LivePathEffectObject
 
diff --git a/src/live_effects/parameter/Makefile_insert b/src/live_effects/parameter/Makefile_insert
deleted file mode 100644
index ab4a8eb4e..000000000
--- a/src/live_effects/parameter/Makefile_insert
+++ /dev/null
@@ -1,36 +0,0 @@
-## Makefile.am fragment sourced by src/Makefile.am.
-
-ink_common_sources += \
-	live_effects/parameter/parameter.cpp	\
-	live_effects/parameter/parameter.h	\
-	live_effects/parameter/array.cpp	\
-	live_effects/parameter/array.h	\
-	live_effects/parameter/bool.cpp	\
-	live_effects/parameter/bool.h	\
-	live_effects/parameter/random.cpp	\
-	live_effects/parameter/random.h	\
-	live_effects/parameter/point.cpp	\
-	live_effects/parameter/point.h	\
-	live_effects/parameter/enum.h	\
-	live_effects/parameter/path-reference.cpp	\
-	live_effects/parameter/path-reference.h	\
-	live_effects/parameter/path.cpp	\
-	live_effects/parameter/path.h	\
-	live_effects/parameter/originalpath.cpp	\
-	live_effects/parameter/originalpath.h	\
-	live_effects/parameter/originalpatharray.cpp	\
-	live_effects/parameter/originalpatharray.h	\
-	live_effects/parameter/powerstrokepointarray.cpp	\
-	live_effects/parameter/powerstrokepointarray.h	\
-	live_effects/parameter/satellitesarray.cpp	\
-	live_effects/parameter/satellitesarray.h	\
-	live_effects/parameter/text.cpp	\
-	live_effects/parameter/text.h	\
-	live_effects/parameter/transformedpoint.cpp	\
-	live_effects/parameter/transformedpoint.h	\
-	live_effects/parameter/togglebutton.cpp	\
-	live_effects/parameter/togglebutton.h	\
-	live_effects/parameter/unit.cpp	\
-	live_effects/parameter/unit.h	\
-	live_effects/parameter/vector.cpp	\
-	live_effects/parameter/vector.h
diff --git a/src/live_effects/parameter/bool.cpp b/src/live_effects/parameter/bool.cpp
index 9ecadbdeb..af99ef362 100644
--- a/src/live_effects/parameter/bool.cpp
+++ b/src/live_effects/parameter/bool.cpp
@@ -36,6 +36,12 @@ BoolParam::param_set_default()
     param_setValue(defvalue);
 }
 
+void 
+BoolParam::param_update_default(bool const default_value)
+{
+    defvalue = default_value;
+}
+
 bool
 BoolParam::param_readSVGValue(const gchar * strvalue)
 {
diff --git a/src/live_effects/parameter/bool.h b/src/live_effects/parameter/bool.h
index 403dd0b87..7ad8a9368 100644
--- a/src/live_effects/parameter/bool.h
+++ b/src/live_effects/parameter/bool.h
@@ -36,7 +36,7 @@ public:
 
     void param_setValue(bool newvalue);
     virtual void param_set_default();
-
+    void param_update_default(bool const default_value);
     bool get_value() const { return value; };
 
     inline operator bool() const { return value; };
diff --git a/src/live_effects/parameter/enum.h b/src/live_effects/parameter/enum.h
index 2340663c3..dbfc68623 100644
--- a/src/live_effects/parameter/enum.h
+++ b/src/live_effects/parameter/enum.h
@@ -27,12 +27,14 @@ public:
                 const Util::EnumDataConverter<E>& c,
                 Inkscape::UI::Widget::Registry* wr,
                 Effect* effect,
-                E default_value)
+                E default_value,
+                bool sort = true)
         : Parameter(label, tip, key, wr, effect)
     {
         enumdataconv = &c;
         defvalue = default_value;
         value = defvalue;
+        sorted = sort;
     };
 
     virtual ~EnumParam() { };
@@ -40,12 +42,11 @@ public:
     virtual Gtk::Widget * param_newWidget() {
         Inkscape::UI::Widget::RegisteredEnum<E> *regenum = Gtk::manage ( 
             new Inkscape::UI::Widget::RegisteredEnum<E>( param_label, param_tooltip,
-                       param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc() ) );
+                       param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc(), sorted ) );
 
         regenum->set_active_by_id(value);
         regenum->combobox()->setProgrammatically = false;
         regenum->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change enumeration parameter"));
-
         return dynamic_cast<Gtk::Widget *> (regenum);
     };
 
@@ -86,6 +87,7 @@ private:
 
     E value;
     E defvalue;
+    bool sorted;
 
     const Util::EnumDataConverter<E> * enumdataconv;
 };
diff --git a/src/live_effects/parameter/fontbutton.cpp b/src/live_effects/parameter/fontbutton.cpp
new file mode 100644
index 000000000..64c203093
--- /dev/null
+++ b/src/live_effects/parameter/fontbutton.cpp
@@ -0,0 +1,92 @@
+/*
+ * Authors:
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include <gtkmm.h>
+#include "ui/widget/registered-widget.h"
+#include "live_effects/parameter/fontbutton.h"
+#include "live_effects/effect.h"
+#include "ui/widget/font-button.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "verbs.h"
+
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+FontButtonParam::FontButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
+                      const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
+                      Effect* effect, const Glib::ustring default_value )
+    : Parameter(label, tip, key, wr, effect),
+      value(default_value),
+      defvalue(default_value)
+{
+}
+
+void
+FontButtonParam::param_set_default()
+{
+    param_setValue(defvalue);
+}
+void 
+FontButtonParam::param_update_default(const Glib::ustring default_value){
+    defvalue = default_value;
+}
+
+bool
+FontButtonParam::param_readSVGValue(const gchar * strvalue)
+{
+    Inkscape::SVGOStringStream os;
+    os << strvalue;
+    param_setValue((Glib::ustring)os.str());
+    return true;
+}
+
+gchar *
+FontButtonParam::param_getSVGValue() const
+{
+    return g_strdup(value.c_str());
+}
+
+Gtk::Widget *
+FontButtonParam::param_newWidget()
+{
+    Inkscape::UI::Widget::RegisteredFontButton * fontbuttonwdg = Gtk::manage(
+        new Inkscape::UI::Widget::RegisteredFontButton( param_label,
+                                                        param_tooltip,
+                                                        param_key,
+                                                        *param_wr,
+                                                        param_effect->getRepr(),
+                                                        param_effect->getSPDoc() ) );
+    Glib::ustring fontspec = param_getSVGValue();
+    fontbuttonwdg->setValue( fontspec);
+    fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
+    param_effect->upd_params = false;
+    return dynamic_cast<Gtk::Widget *> (fontbuttonwdg);
+}
+
+void
+FontButtonParam::param_setValue(const Glib::ustring newvalue)
+{
+    value = newvalue;
+}
+
+} /* namespace LivePathEffect */
+
+} /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/parameter/fontbutton.h b/src/live_effects/parameter/fontbutton.h
new file mode 100644
index 000000000..df47251a2
--- /dev/null
+++ b/src/live_effects/parameter/fontbutton.h
@@ -0,0 +1,61 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+ * Authors:
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include <glib.h>
+#include "live_effects/parameter/parameter.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class FontButtonParam : public Parameter {
+public:
+    FontButtonParam( const Glib::ustring& label,
+               const Glib::ustring& tip,
+               const Glib::ustring& key,
+               Inkscape::UI::Widget::Registry* wr,
+               Effect* effect,
+               const Glib::ustring default_value = "");
+    virtual ~FontButtonParam() {}
+
+    virtual Gtk::Widget * param_newWidget();
+    virtual bool param_readSVGValue(const gchar * strvalue);
+    void param_update_default(const Glib::ustring defvalue);
+    virtual gchar * param_getSVGValue() const;
+
+    void param_setValue(const Glib::ustring newvalue);
+    
+    virtual void param_set_default();
+
+    const Glib::ustring get_value() const { return defvalue; };
+
+private:
+    FontButtonParam(const FontButtonParam&);
+    FontButtonParam& operator=(const FontButtonParam&);
+    Glib::ustring value;
+    Glib::ustring defvalue;
+
+};
+
+} //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/originalpath.cpp b/src/live_effects/parameter/originalpath.cpp
index 2741461be..f7eb48b7a 100644
--- a/src/live_effects/parameter/originalpath.cpp
+++ b/src/live_effects/parameter/originalpath.cpp
@@ -56,7 +56,7 @@ OriginalPathParam::param_newWidget()
     }
 
     { // Paste path to link button
-        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( INKSCAPE_ICON("edit-paste"), Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon( INKSCAPE_ICON("edit-clone"), Inkscape::ICON_SIZE_BUTTON) );
         Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
         pButton->set_relief(Gtk::RELIEF_NONE);
         pIcon->show();
diff --git a/src/live_effects/parameter/originalpatharray.cpp b/src/live_effects/parameter/originalpatharray.cpp
index 4ee068ebf..083abc94c 100644
--- a/src/live_effects/parameter/originalpatharray.cpp
+++ b/src/live_effects/parameter/originalpatharray.cpp
@@ -144,7 +144,7 @@ Gtk::Widget* OriginalPathArrayParam::param_newWidget()
     
     
     { // Paste path to link button
-        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon("gtk-stock", Inkscape::ICON_SIZE_BUTTON) );
+        Gtk::Widget *pIcon = Gtk::manage( sp_icon_get_icon("edit-clone", Inkscape::ICON_SIZE_BUTTON) );
         Gtk::Button *pButton = Gtk::manage(new Gtk::Button());
         pButton->set_relief(Gtk::RELIEF_NONE);
         pIcon->show();
diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index d4e213948..befac4df1 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -4,11 +4,9 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "ui/widget/registered-widget.h"
-#include <glibmm/i18n.h>
 
-#include "live_effects/parameter/parameter.h"
 #include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
 #include "svg/svg.h"
 #include "xml/repr.h"
 
@@ -16,6 +14,8 @@
 
 #include "verbs.h"
 
+#include <glibmm/i18n.h>
+
 #define noLPEREALPARAM_DEBUG
 
 namespace Inkscape {
@@ -101,9 +101,16 @@ ScalarParam::param_set_default()
     param_set_value(defvalue);
 }
 
+void 
+ScalarParam::param_update_default(gdouble default_value)
+{
+    defvalue = default_value;
+}
+
 void
 ScalarParam::param_set_value(gdouble val)
 {
+    param_effect->upd_params = true;
     value = val;
     if (integer)
         value = round(value);
@@ -121,7 +128,7 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     // 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.
-
+    param_effect->upd_params = true;
     if (min >= -SCALARPARAM_G_MAXDOUBLE) {
         this->min = min;
     } else {
@@ -130,15 +137,15 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     if (max <= SCALARPARAM_G_MAXDOUBLE) {
         this->max = max;
     } else {
-	this->max = SCALARPARAM_G_MAXDOUBLE;
+        this->max = SCALARPARAM_G_MAXDOUBLE;
     }
-
     param_set_value(value); // reset value to see whether it is in ranges
 }
 
 void
 ScalarParam::param_make_integer(bool yes)
 {
+    param_effect->upd_params = true;
     integer = yes;
     digits = 0;
     inc_step = 1;
@@ -169,6 +176,7 @@ ScalarParam::param_newWidget()
         if(!overwrite_widget){
             rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
         }
+        param_effect->upd_params = false;
         return dynamic_cast<Gtk::Widget *> (rsu);
     } else {
         return NULL;
@@ -178,12 +186,14 @@ ScalarParam::param_newWidget()
 void
 ScalarParam::param_set_digits(unsigned digits)
 {
+    param_effect->upd_params = true;
     this->digits = digits;
 }
 
 void
 ScalarParam::param_set_increments(double step, double page)
 {
+    param_effect->upd_params = true;
     inc_step = step;
     inc_page = page;
 }
diff --git a/src/live_effects/parameter/parameter.h b/src/live_effects/parameter/parameter.h
index 0ef28650a..6cf10710c 100644
--- a/src/live_effects/parameter/parameter.h
+++ b/src/live_effects/parameter/parameter.h
@@ -12,6 +12,7 @@
 #include <glibmm/ustring.h>
 #include <2geom/forward.h>
 #include <2geom/pathvector.h>
+#include "ui/widget/registered-widget.h"
 
 // In gtk2, this wasn't an issue; we could toss around
 // G_MAXDOUBLE and not worry about size allocations. But
@@ -67,7 +68,7 @@ public:
 
     // overload these for your particular parameter to make it provide knotholder handles or canvas helperpaths
     virtual bool providesKnotHolderEntities() const { return false; }
-    virtual void addKnotHolderEntities(KnotHolder */*knotholder*/, SPDesktop */*desktop*/, SPItem */*item*/) {};
+    virtual void addKnotHolderEntities(KnotHolder */*knotholder*/, SPItem */*item*/) {};
     virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathVector> &/*hp_vec*/) {};
 
     virtual void param_editOncanvas(SPItem * /*item*/, SPDesktop * /*dt*/) {};
@@ -110,13 +111,15 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     virtual void param_set_default();
+    void param_update_default(gdouble default_value);
     void param_set_value(gdouble val);
     void param_make_integer(bool yes = true);
     void param_set_range(gdouble min, gdouble max);
     void param_set_digits(unsigned digits);
     void param_set_increments(double step, double page);
-
     void addSlider(bool add_slider_widget) { add_slider = add_slider_widget; };
+    double param_get_max() { return max; };
+    double param_get_min() { return min; };
 
     void param_overwrite_widget(bool overwrite_widget);
     virtual Gtk::Widget * param_newWidget();
diff --git a/src/live_effects/parameter/path.cpp b/src/live_effects/parameter/path.cpp
index bed191e83..f0c494267 100644
--- a/src/live_effects/parameter/path.cpp
+++ b/src/live_effects/parameter/path.cpp
@@ -237,7 +237,6 @@ PathParam::param_editOncanvas(SPItem *item, SPDesktop * dt)
 
     r.role = SHAPE_ROLE_LPE_PARAM;
     r.edit_transform = item->i2dt_affine(); // TODO is it right?
-    r.edit_transform *= item->transform.inverse();
     if (!href) {
         r.item = reinterpret_cast<SPItem*>(param_effect->getLPEObj());
         r.lpe_key = param_key;
@@ -458,8 +457,7 @@ PathParam::paste_param_path(const char *svgd)
         SPItem * item = SP_ACTIVE_DESKTOP->getSelection()->singleItem();
         if (item != NULL) {
             Geom::PathVector path_clipboard =  sp_svg_read_pathv(svgd);
-            path_clipboard *= item->i2doc_affine().inverse() * item->transform;
-            path_clipboard *= Geom::Translate(path_clipboard.initialPoint() - _pathvector.initialPoint()).inverse();
+            path_clipboard *= item->i2doc_affine().inverse();
             svgd = sp_svg_write_path( path_clipboard );
         }
         
diff --git a/src/live_effects/parameter/point.cpp b/src/live_effects/parameter/point.cpp
index ca3471b29..c87b1e299 100644
--- a/src/live_effects/parameter/point.cpp
+++ b/src/live_effects/parameter/point.cpp
@@ -4,7 +4,6 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "ui/widget/registered-widget.h"
 #include "live_effects/parameter/point.h"
 #include "live_effects/effect.h"
 #include "svg/svg.h"
@@ -16,9 +15,6 @@
 #include "knotholder.h"
 #include <glibmm/i18n.h>
 
-// needed for on-canvas editting:
-#include "desktop.h"
-
 namespace Inkscape {
 
 namespace LivePathEffect {
@@ -30,7 +26,8 @@ PointParam::PointParam( const Glib::ustring& label, const Glib::ustring& tip,
     :   Parameter(label, tip, key, wr, effect), 
         defvalue(default_value),
         liveupdate(live_update),
-        knoth(NULL)
+        knoth(NULL),
+        _pointwdg(NULL)
 {
     knot_shape = SP_KNOT_SHAPE_DIAMOND;
     knot_mode  = SP_KNOT_MODE_XOR;
@@ -62,9 +59,9 @@ PointParam::param_get_default() const{
 }
 
 void
-PointParam::param_update_default(Geom::Point newpoint)
+PointParam::param_update_default(const Geom::Point default_point)
 {
-    defvalue = newpoint;
+    defvalue = default_point;
 }
 
 void
@@ -81,6 +78,9 @@ PointParam::param_setValue(Geom::Point newpoint, bool write)
     if(knoth && liveupdate){
         knoth->update_knots();
     }
+    if (_pointwdg) {
+        _pointwdg->setValue( newpoint );
+    }
 }
 
 bool
@@ -116,25 +116,24 @@ PointParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
 Gtk::Widget *
 PointParam::param_newWidget()
 {
-    Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg = Gtk::manage(
+    _pointwdg = Gtk::manage(
         new Inkscape::UI::Widget::RegisteredTransformedPoint( param_label,
                                                               param_tooltip,
                                                               param_key,
                                                               *param_wr,
                                                               param_effect->getRepr(),
                                                               param_effect->getSPDoc() ) );
-    // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    Geom::Affine transf = desktop->doc2dt();
-    pointwdg->setTransform(transf);
-    pointwdg->setValue( *this );
-    pointwdg->clearProgrammatically();
-    pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
+    Geom::Affine transf = Geom::Scale(1, -1);
+    transf[5] = SP_ACTIVE_DOCUMENT->getHeight().value("px");
+    _pointwdg->setTransform(transf);
+    _pointwdg->setValue( *this );
+    _pointwdg->clearProgrammatically();
+    _pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
 
     Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
-    static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
+    static_cast<Gtk::HBox*>(hbox)->pack_start(*_pointwdg, true, true);
     static_cast<Gtk::HBox*>(hbox)->show_all_children();
-
+    param_effect->upd_params = false;
     return dynamic_cast<Gtk::Widget *> (hbox);
 }
 
@@ -191,23 +190,23 @@ void
 PointParamKnotHolderEntity::knot_click(guint state)
 {
     if (state & GDK_CONTROL_MASK) {
-            if (state & GDK_MOD1_MASK) {
-                this->pparam->param_set_default();
-                SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
-                if(splpeitem){
-                    sp_lpe_item_update_patheffect(splpeitem, false, false);
-                }
+        if (state & GDK_MOD1_MASK) {
+            this->pparam->param_set_default();
+            SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
+            if(splpeitem){
+                sp_lpe_item_update_patheffect(splpeitem, false, false);
             }
+        }
     }
 }
 
 void
-PointParam::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+PointParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     knoth = knotholder;
     PointParamKnotHolderEntity *e = new PointParamKnotHolderEntity(this);
     // TODO: can we ditch handleTip() etc. because we have access to handle_tip etc. itself???
-    e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), knot_shape, knot_mode, knot_color);
+    e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), knot_shape, knot_mode, knot_color);
     knotholder->add(e);
 }
 
diff --git a/src/live_effects/parameter/point.h b/src/live_effects/parameter/point.h
index 4329e0bcd..e8cb66225 100644
--- a/src/live_effects/parameter/point.h
+++ b/src/live_effects/parameter/point.h
@@ -11,7 +11,7 @@
 
 #include <glib.h>
 #include <2geom/point.h>
-
+#include "ui/widget/registered-widget.h"
 #include "live_effects/parameter/parameter.h"
 
 #include "knot-holder-entity.h"
@@ -43,13 +43,13 @@ public:
     void param_set_default();
     Geom::Point param_get_default() const;
     void param_set_liveupdate(bool live_update);
-    void param_update_default(Geom::Point newpoint);
+    void param_update_default(const Geom::Point default_point);
     virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
 
     void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
 
     virtual bool providesKnotHolderEntities() const { return true; }
-    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
     friend class PointParamKnotHolderEntity;
 private:
@@ -62,6 +62,7 @@ private:
     SPKnotModeType knot_mode;
     guint32 knot_color;
     gchar *handle_tip;
+    Inkscape::UI::Widget::RegisteredTransformedPoint * _pointwdg;
 };
 
 
diff --git a/src/live_effects/parameter/powerstrokepointarray.cpp b/src/live_effects/parameter/powerstrokepointarray.cpp
index c61e8f9cb..7753d819d 100644
--- a/src/live_effects/parameter/powerstrokepointarray.cpp
+++ b/src/live_effects/parameter/powerstrokepointarray.cpp
@@ -248,11 +248,11 @@ PowerStrokePointArrayParamKnotHolderEntity::knot_click(guint state)
     } 
 }
 
-void PowerStrokePointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+void PowerStrokePointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     for (unsigned int i = 0; i < _vector.size(); ++i) {
         PowerStrokePointArrayParamKnotHolderEntity *e = new PowerStrokePointArrayParamKnotHolderEntity(this, i);
-        e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
+        e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
                    _("<b>Stroke width control point</b>: drag to alter the stroke width. <b>Ctrl+click</b> adds a control point, <b>Ctrl+Alt+click</b> deletes it, <b>Shift+click</b> launches width dialog."),
                    knot_shape, knot_mode, knot_color);
         knotholder->add(e);
diff --git a/src/live_effects/parameter/powerstrokepointarray.h b/src/live_effects/parameter/powerstrokepointarray.h
index 70b22e27e..56a609fa8 100644
--- a/src/live_effects/parameter/powerstrokepointarray.h
+++ b/src/live_effects/parameter/powerstrokepointarray.h
@@ -38,7 +38,7 @@ public:
     float median_width();
 
     virtual bool providesKnotHolderEntities() const { return true; }
-    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
     void set_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in, Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_normal_in);
     Geom::Piecewise<Geom::D2<Geom::SBasis> > const & get_pwd2() const { return last_pwd2; }
diff --git a/src/live_effects/parameter/text.cpp b/src/live_effects/parameter/text.cpp
index 234a6174d..8cab68ad0 100644
--- a/src/live_effects/parameter/text.cpp
+++ b/src/live_effects/parameter/text.cpp
@@ -31,12 +31,16 @@ TextParam::TextParam( const Glib::ustring& label, const Glib::ustring& tip,
                       Effect* effect, const Glib::ustring default_value )
     : Parameter(label, tip, key, wr, effect),
       value(default_value),
-      defvalue(default_value)
+      defvalue(default_value),
+      _hide_canvas_text(false)
 {
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP; // FIXME: we shouldn't use this!
-    canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
-    sp_canvastext_set_text (canvas_text, default_value.c_str());
-    sp_canvastext_set_coords (canvas_text, 0, 0);
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) { // FIXME: we shouldn't use this!
+        canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
+        sp_canvastext_set_text (canvas_text, default_value.c_str());
+        sp_canvastext_set_coords (canvas_text, 0, 0);
+    } else {
+        _hide_canvas_text = true;
+    }
 }
 
 void
@@ -46,9 +50,26 @@ TextParam::param_set_default()
 }
 
 void
+TextParam::param_update_default(Glib::ustring default_value)
+{
+    defvalue = default_value;
+}
+
+void
+TextParam::param_hide_canvas_text()
+{
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_text(canvas_text, " ");
+        _hide_canvas_text = true;
+    }
+}
+
+void
 TextParam::setPos(Geom::Point pos)
 {
-    sp_canvastext_set_coords (canvas_text, pos);
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_coords (canvas_text, pos);
+    }
 }
 
 void
@@ -63,9 +84,10 @@ TextParam::setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
     Point dir = unit_vector(derivative(pwd2_reparam).valueAt(t_reparam));
     Point n = -rot90(dir);
     double angle = Geom::angle_between(dir, Point(1,0));
-
-    sp_canvastext_set_coords(canvas_text, pos + n * length);
-    sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_coords(canvas_text, pos + n * length);
+        sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
+    }
 }
 
 void
@@ -73,7 +95,9 @@ TextParam::setAnchor(double x_value, double y_value)
 {
     anchor_x = x_value;
     anchor_y = y_value;
-    sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
+    }
 }
 
 bool
@@ -86,7 +110,10 @@ TextParam::param_readSVGValue(const gchar * strvalue)
 gchar *
 TextParam::param_getSVGValue() const
 {
-    return g_strdup(value.c_str());
+    Inkscape::SVGOStringStream os;
+    os << value;
+    gchar * str = g_strdup(os.str().c_str());
+    return str;
 }
 
 Gtk::Widget *
@@ -94,8 +121,7 @@ TextParam::param_newWidget()
 {
     Inkscape::UI::Widget::RegisteredText *rsu = Gtk::manage(new Inkscape::UI::Widget::RegisteredText(
         param_label, param_tooltip, param_key, *param_wr, param_effect->getRepr(), param_effect->getSPDoc()));
-
-    rsu->setText(value.c_str());
+    rsu->setText(value);
     rsu->setProgrammatically = false;
 
     rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change text parameter"));
@@ -107,8 +133,9 @@ void
 TextParam::param_setValue(const Glib::ustring newvalue)
 {
     value = newvalue;
-
-    sp_canvastext_set_text (canvas_text, newvalue.c_str());
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_text (canvas_text, newvalue.c_str());
+    }
 }
 
 } /* namespace LivePathEffect */
diff --git a/src/live_effects/parameter/text.h b/src/live_effects/parameter/text.h
index 62de70eec..553c84c0a 100644
--- a/src/live_effects/parameter/text.h
+++ b/src/live_effects/parameter/text.h
@@ -40,7 +40,9 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     void param_setValue(const Glib::ustring newvalue);
+    void param_hide_canvas_text();
     virtual void param_set_default();
+    void param_update_default(Glib::ustring default_value);
     void setPos(Geom::Point pos);
     void setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
 			 const double t, const double length, bool use_curvature = false);
@@ -53,7 +55,7 @@ private:
     TextParam& operator=(const TextParam&);
     double anchor_x;
     double anchor_y;
-
+    bool _hide_canvas_text;
     Glib::ustring value;
     Glib::ustring defvalue;
 
diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp
index 47a8b5615..b3f6442bb 100644
--- a/src/live_effects/parameter/togglebutton.cpp
+++ b/src/live_effects/parameter/togglebutton.cpp
@@ -12,6 +12,7 @@
 #include "live_effects/effect.h"
 #include "svg/svg.h"
 #include "svg/stringstream.h"
+#include "selection.h"
 #include "widgets/icon.h"
 #include "inkscape.h"
 #include "verbs.h"
@@ -24,10 +25,10 @@ namespace LivePathEffect {
 ToggleButtonParam::ToggleButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
                       const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
                       Effect* effect, bool default_value, const Glib::ustring& inactive_label,
-                      char const * icon_active, char const * icon_inactive, 
-                      Inkscape::IconSize icon_size)
+                      char const * _icon_active, char const * _icon_inactive, 
+                      Inkscape::IconSize _icon_size)
     : Parameter(label, tip, key, wr, effect), value(default_value), defvalue(default_value),
-      inactiveLabel(inactive_label), iconActive(icon_active), iconInactive(icon_inactive), iconSize(icon_size)
+      inactive_label(inactive_label), _icon_active(_icon_active), _icon_inactive(_icon_inactive), _icon_size(_icon_size)
 {
     checkwdg = NULL;
 }
@@ -74,45 +75,44 @@ ToggleButtonParam::param_newWidget()
                                                          false,
                                                          param_effect->getRepr(),
                                                          param_effect->getSPDoc()) );
-#if GTK_CHECK_VERSION(3,0,0)
-    GtkWidget * boxButton = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
-    gtk_box_set_homogeneous(GTK_BOX(boxButton), false);
-#else
-    GtkWidget * boxButton = gtk_hbox_new (false, 0);
-#endif
-    GtkWidget * labelButton = gtk_label_new ("");
+    auto box_button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+    gtk_box_set_homogeneous(GTK_BOX(box_button), false);
+    GtkWidget * label_button = gtk_label_new ("");
     if (!param_label.empty()) {
-        if(value || inactiveLabel.empty()){
-            gtk_label_set_text(GTK_LABEL(labelButton), param_label.c_str());
+        if(value || inactive_label.empty()){
+            gtk_label_set_text(GTK_LABEL(label_button), param_label.c_str());
         }else{
-            gtk_label_set_text(GTK_LABEL(labelButton), inactiveLabel.c_str());
+            gtk_label_set_text(GTK_LABEL(label_button), inactive_label.c_str());
         }
     }
-    gtk_widget_show(labelButton);
-    if ( iconActive ) {
-        if(!iconInactive){
-            iconInactive = iconActive;
+    gtk_widget_show(label_button);
+    if ( _icon_active ) {
+        if(!_icon_inactive){
+            _icon_inactive = _icon_active;
         }
-        gtk_widget_show(boxButton);
-        GtkWidget *iconButton = sp_icon_new(iconSize, iconActive);
+        gtk_widget_show(box_button);
+        GtkWidget *icon_button = NULL;
         if(!value){ 
-            iconButton = sp_icon_new(iconSize, iconInactive);
+            icon_button = sp_icon_new(_icon_size, _icon_inactive);
+        } else {
+            icon_button = sp_icon_new(_icon_size, _icon_active);
         }
-        gtk_widget_show(iconButton);
-        gtk_box_pack_start (GTK_BOX(boxButton), iconButton, false, false, 1);
+        gtk_widget_show(icon_button);
+        gtk_box_pack_start (GTK_BOX(box_button), icon_button, false, false, 1);
         if (!param_label.empty()) {
-            gtk_box_pack_start (GTK_BOX(boxButton), labelButton, false, false, 1);
+            gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1);
         }
     }else{
-        gtk_box_pack_start (GTK_BOX(boxButton), labelButton, false, false, 1);
+        gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1);
     }
-    checkwdg->add(*Gtk::manage(Glib::wrap(boxButton)));
+
+    checkwdg->add(*Gtk::manage(Glib::wrap(box_button)));
     checkwdg->setActive(value);
     checkwdg->setProgrammatically = false;
     checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
 
     _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
-
+    param_effect->upd_params = false;
     return checkwdg;
 }
 
@@ -126,25 +126,27 @@ ToggleButtonParam::refresh_button()
     if(!checkwdg){
         return;
     }
-    Gtk::Widget * boxButton = checkwdg->get_child();
-    if(!boxButton){
+    Gtk::Widget * box_button = checkwdg->get_child();
+    if(!box_button){
         return;
     }
-    GList * childs = gtk_container_get_children(GTK_CONTAINER(boxButton->gobj()));
-    guint totalWidgets = g_list_length (childs);
+    GList * childs = gtk_container_get_children(GTK_CONTAINER(box_button->gobj()));
+    guint total_widgets = g_list_length (childs);
     if (!param_label.empty()) {
-        if(value || inactiveLabel.empty()){
-            gtk_label_set_text(GTK_LABEL(g_list_nth_data(childs, totalWidgets-1)), param_label.c_str());
+        if(value || inactive_label.empty()){
+            gtk_label_set_text(GTK_LABEL(g_list_nth_data(childs, total_widgets-1)), param_label.c_str());
         }else{
-            gtk_label_set_text(GTK_LABEL(g_list_nth_data(childs, totalWidgets-1)), inactiveLabel.c_str());
+            gtk_label_set_text(GTK_LABEL(g_list_nth_data(childs, total_widgets-1)), inactive_label.c_str());
         }
     }
-    if ( iconActive ) {
-        GdkPixbuf * iconPixbuf = sp_pixbuf_new( iconSize, iconActive );
+    if ( _icon_active ) {
+        GdkPixbuf * icon_pixbuf = NULL;
         if(!value){ 
-            iconPixbuf = sp_pixbuf_new( iconSize, iconInactive);
+            icon_pixbuf = sp_pixbuf_new( _icon_size, _icon_inactive );
+        } else {
+            icon_pixbuf = sp_pixbuf_new( _icon_size, _icon_active );
         }
-        gtk_image_set_from_pixbuf (GTK_IMAGE(g_list_nth_data(childs, 0)), iconPixbuf);
+        gtk_image_set_from_pixbuf (GTK_IMAGE(g_list_nth_data(childs, 0)), icon_pixbuf);
     }
 }
 
@@ -157,6 +159,12 @@ ToggleButtonParam::param_setValue(bool newvalue)
 
 void
 ToggleButtonParam::toggled() {
+    //Force redraw for update widgets
+    param_effect->upd_params = true;
+    if (SP_ACTIVE_DESKTOP) {
+        Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
+        selection->emitModified();
+    }
     _signal_toggled.emit();
 }
 
diff --git a/src/live_effects/parameter/togglebutton.h b/src/live_effects/parameter/togglebutton.h
index 4e545bcfd..8390fec86 100644
--- a/src/live_effects/parameter/togglebutton.h
+++ b/src/live_effects/parameter/togglebutton.h
@@ -59,10 +59,10 @@ private:
     void refresh_button();
     bool value;
     bool defvalue;
-    const Glib::ustring inactiveLabel;
-    const char * iconActive;
-    const char * iconInactive;
-    Inkscape::IconSize  iconSize;
+    const Glib::ustring inactive_label;
+    const char * _icon_active;
+    const char * _icon_inactive;
+    Inkscape::IconSize  _icon_size;
     Inkscape::UI::Widget::RegisteredToggleButton * checkwdg;
 
     sigc::signal<void> _signal_toggled;
diff --git a/src/live_effects/parameter/unit.cpp b/src/live_effects/parameter/unit.cpp
index 0ee553e2c..b6ea99bfe 100644
--- a/src/live_effects/parameter/unit.cpp
+++ b/src/live_effects/parameter/unit.cpp
@@ -54,6 +54,12 @@ UnitParam::param_set_default()
     param_set_value(*defunit);
 }
 
+void 
+UnitParam::param_update_default(const Glib::ustring default_unit)
+{
+    defunit = unit_table.getUnit(default_unit);
+}
+
 void
 UnitParam::param_set_value(Inkscape::Util::Unit const &val)
 {
diff --git a/src/live_effects/parameter/unit.h b/src/live_effects/parameter/unit.h
index 59a483018..ae58cf956 100644
--- a/src/live_effects/parameter/unit.h
+++ b/src/live_effects/parameter/unit.h
@@ -33,6 +33,7 @@ public:
     virtual gchar * param_getSVGValue() const;
     virtual void param_set_default();
     void param_set_value(Inkscape::Util::Unit const &val);
+    void param_update_default(const Glib::ustring default_unit);
     const gchar *get_abbreviation() const;
 
     virtual Gtk::Widget * param_newWidget();
diff --git a/src/live_effects/parameter/vector.cpp b/src/live_effects/parameter/vector.cpp
index cfaa9e7e7..55b4d4b32 100644
--- a/src/live_effects/parameter/vector.cpp
+++ b/src/live_effects/parameter/vector.cpp
@@ -14,7 +14,6 @@
 #include "svg/stringstream.h"
 
 #include "live_effects/effect.h"
-#include "desktop.h"
 #include "verbs.h"
 
 namespace Inkscape {
@@ -117,7 +116,7 @@ VectorParam::set_and_write_new_values(Geom::Point const &new_origin, Geom::Point
 void
 VectorParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
 {
-        set_and_write_new_values( origin * postmul, vector * postmul.withoutTranslation() );
+    set_and_write_new_values( origin * postmul, vector * postmul.withoutTranslation() );
 }
 
 
@@ -188,14 +187,14 @@ private:
 };
 
 void
-VectorParam::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item)
+VectorParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item)
 {
     VectorParamKnotHolderEntity_Origin *origin_e = new VectorParamKnotHolderEntity_Origin(this);
-    origin_e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), ori_knot_shape, ori_knot_mode, ori_knot_color);
+    origin_e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), ori_knot_shape, ori_knot_mode, ori_knot_color);
     knotholder->add(origin_e);
 
     VectorParamKnotHolderEntity_Vector *vector_e = new VectorParamKnotHolderEntity_Vector(this);
-    vector_e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), vec_knot_shape, vec_knot_mode, vec_knot_color);
+    vector_e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, handleTip(), vec_knot_shape, vec_knot_mode, vec_knot_color);
     knotholder->add(vector_e);
 }
 
diff --git a/src/live_effects/parameter/vector.h b/src/live_effects/parameter/vector.h
index 35ca04437..edee4ff4d 100644
--- a/src/live_effects/parameter/vector.h
+++ b/src/live_effects/parameter/vector.h
@@ -53,7 +53,7 @@ public:
     void set_oncanvas_color(guint32 color);
 
     virtual bool providesKnotHolderEntities() const { return true; }
-    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
+    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
 
 private:
     VectorParam(const VectorParam&);
diff --git a/src/live_effects/spiro.cpp b/src/live_effects/spiro.cpp
index 0ac2815bf..a2ff4813e 100644
--- a/src/live_effects/spiro.cpp
+++ b/src/live_effects/spiro.cpp
@@ -29,7 +29,6 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 #include <string.h>
 
 #include "display/curve.h"
-#include <2geom/math-utils.h>
 
 #define SPIRO_SHOW_INFINITE_COORDINATE_CALLS