fixing to new trunk

(bzr r15142.1.38)

82 files changed, 957 insertions, 1054 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 792bb5d7a..5cc0d6f20 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -350,6 +350,7 @@ 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),
@@ -611,15 +612,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);
     }
 }
 
@@ -659,14 +660,7 @@ Effect::addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector<Geom::PathV
  */
 void
 Effect::update_helperpath() {
-    using namespace Inkscape::UI;
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    if (desktop) {
-        if (tools_isactive(desktop, TOOLS_NODES)) {
-            Inkscape::UI::Tools::NodeTool *nt = static_cast<Inkscape::UI::Tools::NodeTool*>(desktop->event_context);
-            nt->update_helperpath();
-        }
-    }
+    Inkscape::UI::Tools::sp_update_helperpath();
 }
 
 /**
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index 5ca53486c..1997ff0ca 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -100,7 +100,7 @@ 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();
 
@@ -123,6 +123,7 @@ 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:
@@ -141,7 +142,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 9bfbf4ca8..56d33eb4b 100644
--- a/src/live_effects/lpe-angle_bisector.cpp
+++ b/src/live_effects/lpe-angle_bisector.cpp
@@ -8,15 +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/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 d2b44dd4e..302165719 100644
--- a/src/live_effects/lpe-attach-path.cpp
+++ b/src/live_effects/lpe-attach-path.cpp
@@ -4,15 +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-shape.h"
 #include "sp-text.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-bendpath.cpp b/src/live_effects/lpe-bendpath.cpp
index c24d38d7b..b1e133292 100644
--- a/src/live_effects/lpe-bendpath.cpp
+++ b/src/live_effects/lpe-bendpath.cpp
@@ -7,9 +7,10 @@
 
 #include "live_effects/lpe-bendpath.h"
 #include "sp-item-group.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>
 
 using std::vector;
 
diff --git a/src/live_effects/lpe-bounding-box.cpp b/src/live_effects/lpe-bounding-box.cpp
index 2de768c3a..11fb34e04 100644
--- a/src/live_effects/lpe-bounding-box.cpp
+++ b/src/live_effects/lpe-bounding-box.cpp
@@ -3,14 +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-shape.h"
 #include "sp-text.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-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 18252f6a0..3410b13f2 100644
--- a/src/live_effects/lpe-circle_3pts.cpp
+++ b/src/live_effects/lpe-circle_3pts.cpp
@@ -17,6 +17,8 @@
 // You might need to include other 2geom files. You can add them here:
 #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 6e03cb1ce..fcefc4ec6 100644
--- a/src/live_effects/lpe-circle_with_radius.cpp
+++ b/src/live_effects/lpe-circle_with_radius.cpp
@@ -17,6 +17,8 @@
 // You might need to include other 2geom files. You can add them here:
 #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 4af8891e8..8d24f9f47 100644
--- a/src/live_effects/lpe-constructgrid.cpp
+++ b/src/live_effects/lpe-constructgrid.cpp
@@ -10,9 +10,9 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-constructgrid.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 1133e083a..813f25d3d 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -11,36 +11,18 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#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 "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)
 {
@@ -58,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),
-    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()
@@ -87,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)
 {
@@ -95,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);
@@ -104,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) {
@@ -146,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
@@ -235,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;
             }
@@ -388,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;
@@ -418,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 3beedaf57..38cbeaac0 100644
--- a/src/live_effects/lpe-curvestitch.cpp
+++ b/src/live_effects/lpe-curvestitch.cpp
@@ -13,8 +13,6 @@
  */
 
 #include "ui/widget/scalar.h"
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-curvestitch.h"
 
 #include "sp-path.h"
@@ -22,6 +20,9 @@
 #include "xml/repr.h"
 
 #include <2geom/bezier-to-sbasis.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 7e22f6e51..50bbe6451 100644
--- a/src/live_effects/lpe-dynastroke.cpp
+++ b/src/live_effects/lpe-dynastroke.cpp
@@ -16,6 +16,8 @@
 
 #include <2geom/bezier-to-sbasis.h>
 #include <2geom/sbasis-math.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 0371fc313..28e7058d7 100644
--- a/src/live_effects/lpe-ellipse_5pts.cpp
+++ b/src/live_effects/lpe-ellipse_5pts.cpp
@@ -12,15 +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/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 {
diff --git a/src/live_effects/lpe-envelope.cpp b/src/live_effects/lpe-envelope.cpp
index c3b0a7c10..61a696435 100644
--- a/src/live_effects/lpe-envelope.cpp
+++ b/src/live_effects/lpe-envelope.cpp
@@ -6,6 +6,8 @@
 
 #include "live_effects/lpe-envelope.h"
 #include "display/curve.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using std::vector;
 
diff --git a/src/live_effects/lpe-extrude.cpp b/src/live_effects/lpe-extrude.cpp
index d22007f76..daa30d45a 100644
--- a/src/live_effects/lpe-extrude.cpp
+++ b/src/live_effects/lpe-extrude.cpp
@@ -12,10 +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 "sp-item.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index 2087925fa..1e2eadfdb 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -11,7 +11,7 @@
 #include "display/curve.h"
 #include "sp-shape.h"
 #include "sp-text.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
 namespace Inkscape {
diff --git a/src/live_effects/lpe-fill-between-strokes.cpp b/src/live_effects/lpe-fill-between-strokes.cpp
index b1e328d18..0dbebdf26 100644
--- a/src/live_effects/lpe-fill-between-strokes.cpp
+++ b/src/live_effects/lpe-fill-between-strokes.cpp
@@ -3,14 +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-shape.h"
 #include "sp-text.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 24ee2ccc3..1e2df7dc8 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -25,8 +25,8 @@
 
 // for programmatically updating knots
 #include "ui/tools-switch.h"
-
 // 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-gears.cpp b/src/live_effects/lpe-gears.cpp
index 1d5398aa5..dad520041 100644
--- a/src/live_effects/lpe-gears.cpp
+++ b/src/live_effects/lpe-gears.cpp
@@ -7,10 +7,9 @@
  */
 
 #include "live_effects/lpe-gears.h"
-
-#include <glibmm/i18n.h>
-
 #include <2geom/bezier-to-sbasis.h>
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 using std::vector;
 using namespace Geom;
@@ -208,7 +207,7 @@ 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),
-    min_radius(_("Min Radius:"), _("Minimun radius, low balues can slow"), "min_radius", &wr, this, 5.0)
+    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
diff --git a/src/live_effects/lpe-interpolate.cpp b/src/live_effects/lpe-interpolate.cpp
index 43da4d105..e95dc5f38 100644
--- a/src/live_effects/lpe-interpolate.cpp
+++ b/src/live_effects/lpe-interpolate.cpp
@@ -9,15 +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/sbasis-to-bezier.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 ab0576174..0a0bcea14 100644
--- a/src/live_effects/lpe-interpolate_points.cpp
+++ b/src/live_effects/lpe-interpolate_points.cpp
@@ -12,8 +12,9 @@
  */
 
 #include "live_effects/lpe-interpolate_points.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 3bfbd6288..dacb87dd9 100644
--- a/src/live_effects/lpe-jointype.cpp
+++ b/src/live_effects/lpe-jointype.cpp
@@ -19,6 +19,8 @@
 #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 fbc32cf3e..2defecb77 100644
--- a/src/live_effects/lpe-knot.cpp
+++ b/src/live_effects/lpe-knot.cpp
@@ -20,18 +20,21 @@
 #include "knot-holder-entity.h"
 #include "knotholder.h"
 
-#include <glibmm/i18n.h>
 #include <gdk/gdk.h>
 
 #include <2geom/sbasis-to-bezier.h>
 #include <2geom/bezier-to-sbasis.h>
 #include <2geom/basic-intersection.h>
+#include "helper/geom.h"
 
 // for change crossing undo
 #include "verbs.h"
 #include "document.h"
 #include "document-undo.h"
 
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
 namespace Inkscape {
 namespace LivePathEffect {
 
@@ -392,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...
 
@@ -514,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?
@@ -612,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 091b6ddca..acffed000 100644
--- a/src/live_effects/lpe-lattice.cpp
+++ b/src/live_effects/lpe-lattice.cpp
@@ -20,7 +20,8 @@
 
 #include <2geom/sbasis-2d.h>
 #include <2geom/bezier-to-sbasis.h>
-
+// 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 9e9fc153a..e827491c0 100644
--- a/src/live_effects/lpe-lattice2.cpp
+++ b/src/live_effects/lpe-lattice2.cpp
@@ -16,12 +16,15 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <gtkmm.h>
 #include "live_effects/lpe-lattice2.h"
 #include "display/curve.h"
 #include "helper/geom.h"
 #include <2geom/sbasis-2d.h>
 #include <2geom/bezier-to-sbasis.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-lattice2.h b/src/live_effects/lpe-lattice2.h
index 4a025d182..59a0350d3 100644
--- a/src/live_effects/lpe-lattice2.h
+++ b/src/live_effects/lpe-lattice2.h
@@ -18,7 +18,7 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include <gtkmm.h>
+
 #include "live_effects/effect.h"
 #include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/point.h"
diff --git a/src/live_effects/lpe-line_segment.cpp b/src/live_effects/lpe-line_segment.cpp
index 4c9edabd4..cc024fb92 100644
--- a/src/live_effects/lpe-line_segment.cpp
+++ b/src/live_effects/lpe-line_segment.cpp
@@ -13,6 +13,8 @@
 
 #include "live_effects/lpe-line_segment.h"
 #include "ui/tools/lpe-tool.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
index e8ceb7e51..af2a8e919 100644
--- a/src/live_effects/lpe-measure-line.cpp
+++ b/src/live_effects/lpe-measure-line.cpp
@@ -14,8 +14,7 @@
 #include <libnrtype/font-lister.h>
 #include "inkscape.h"
 #include "xml/node.h"
-#include "uri.h"
-#include "uri-references.h"
+#include "xml/sp-css-attr.h"
 #include "preferences.h"
 #include "util/units.h"
 #include "svg/svg-length.h"
@@ -29,7 +28,6 @@
 #include "sp-item.h"
 #include "sp-shape.h"
 #include "sp-path.h"
-#include "desktop.h"
 #include "document.h"
 #include <iomanip>
 
@@ -54,16 +52,17 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     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(_("Positon*"), _("Positon"), "position", &wr, this, 5),
+    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"),
+    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_insensitive(_("Scale insensitive*"), _("Scale insensitive to transforms in element, parents..."), "scale_insensitive", &wr, this, true),
+    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),
@@ -88,7 +87,7 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     registerParameter(&format);
     registerParameter(&arrows_outside);
     registerParameter(&flip_side);
-    registerParameter(&scale_insensitive);
+    registerParameter(&scale_sensitive);
     registerParameter(&local_locale);
     registerParameter(&line_group_05);
     registerParameter(&rotate_anotation);
@@ -97,6 +96,8 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     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()){
@@ -124,7 +125,7 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     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_insensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_insensitive"));
+    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"));
@@ -158,7 +159,8 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     helpline_overlap.param_set_range(-999999.0, 999999.0);
     helpline_overlap.param_set_increments(1, 1);
     helpline_overlap.param_set_digits(2);
-    erase = true;
+    start_stored = Geom::Point(0,0);
+    end_stored = Geom::Point(0,0);
 }
 
 LPEMeasureLine::~LPEMeasureLine() {}
@@ -168,614 +170,568 @@ void swap(Geom::Point &A, Geom::Point &B){
     A = B;
     B = tmp;
 }
-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);
-    }
-}
 
 void
-LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
+LPEMeasureLine::createArrowMarker(const char * mode)
 {
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" +  (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        SPObject *elemref = NULL;
-        Inkscape::XML::Node *node = NULL;
-        if (elemref = SVGElemRef->getObject()) {
-            node = elemref->getRepr();
-            if (!this->isVisible()) {
-                node->setAttribute("style", "display:none");
-            } else {
-                node->setAttribute("style", NULL);
-            }
-        }
-        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" +  (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri2);
-        if (elemref = SVGElemRef->getObject()) {
-            node = elemref->getRepr();
-            if (!this->isVisible()) {
-                node->setAttribute("style", "display:none");
-            } else {
-                node->setAttribute("style", NULL);
-            }
-        }
-        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" +  (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri3);
-        if (elemref = SVGElemRef->getObject()) {
-            node = elemref->getRepr();
-            if (!this->isVisible()) {
-                node->setAttribute("style", "display:none");
-            } else {
-                node->setAttribute("style", NULL);
-            }
-        }
-        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" +  (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri4);
-        if (elemref = SVGElemRef->getObject()) {
-            node = elemref->getRepr();
-            if (!this->isVisible()) {
-                node->setAttribute("style", "display:none");
-            } else {
-                node->setAttribute("style", NULL);
+    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());
             }
         }
-        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" +  (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri5);
-        if (elemref = SVGElemRef->getObject()) {
-            node = elemref->getRepr();
-            if (!this->isVisible()) {
-                node->setAttribute("style", "display:none");
-            } else {
-                node->setAttribute("style", NULL);
-            }
+    } 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::createArrowMarker(Glib::ustring mode)
+LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove, bool valid)
 {
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + mode).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        SPObject *elemref = NULL;
-        Inkscape::XML::Node *arrow = NULL;
-        if (!(elemref = SVGElemRef->getObject())) {
-            arrow = xml_doc->createElement("svg:marker");
-            arrow->setAttribute("id", mode.c_str());
-            arrow->setAttribute("inkscape:stockid", mode.c_str());
-            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 (mode == (Glib::ustring)"ArrowDIN-start") {
-                arrow_path->setAttribute("d", "M -8,0 8,-2.11 8,2.11 z");
-            } else if (mode == (Glib::ustring)"ArrowDIN-end") {
-                arrow_path->setAttribute("d", "M 8,0 -8,2.11 -8,-2.11 z");
-            } else if (mode == (Glib::ustring)"ArrowDINout-start") {
-                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", (mode + (Glib::ustring)"_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(desktop->getDocument()->getDefs()->appendChildRepr(arrow));
-            Inkscape::GC::release(arrow);
-        } else {
-            Inkscape::XML::Node *arrow= elemref->getRepr();
-            if (arrow) {
-                arrow->setAttribute("sodipodi:insensitive", "true");
-                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" );
-                    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());
-                }
-            }
-        }
+    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::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove)
+LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, const char * id, bool main, bool overflow, bool remove, bool arrows)
 {
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
-        Inkscape::XML::Node *rtext = NULL;
-        double doc_w = desktop->getDocument()->getRoot()->width.value;
-        Geom::Scale scale = desktop->getDocument()->getDocumentScale();
-        SPNamedView *nv = desktop->getNamedView();
-        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;
-        }
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" +  (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        SPObject *elemref = NULL;
-        Inkscape::XML::Node *rtspan = NULL;
-        
-        if (elemref = SVGElemRef->getObject()) {
-            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");
-        } else {
-            if (remove) {
-                return;
-            }
-            rtext = xml_doc->createElement("svg:text");
-            rtext->setAttribute("xml:space", "preserve");
-            rtext->setAttribute("id", ( (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-            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");
-        }
-        gchar * 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);
-        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(""));
+    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 {
-            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());
+            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;
         }
-        s = label_value.find((Glib::ustring)"{unit}",0);
-        if(s < label_value.length()) {
-            label_value.replace(s,s+6,unit.get_abbreviation());
+        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;
         }
-        Inkscape::XML::Node *rstring = NULL;
-        if (!elemref) {
-            rstring = xml_doc->createTextNode(label_value.c_str());
-            rtspan->addChild(rstring, NULL);
-            Inkscape::GC::release(rstring);
+        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 {
-            rstring = rtspan->firstChild();
-            rstring->setContent(label_value.c_str());
+            style = style + Glib::ustring("marker-start:url(#ArrowDIN-start);marker-end:url(#ArrowDIN-end);");
         }
-        if (!elemref) {
-            elemref = SP_OBJECT(desktop->currentLayer()->appendChildRepr(rtext));
-            Inkscape::GC::release(rtext);
-        }
-        Inkscape::XML::Node *tmp_node = rtext->duplicate(xml_doc);
-        affine = Geom::Affine(Geom::Scale(1.4));
-        tmp_node->setAttribute("transform", sp_svg_transform_write(affine));
-        SPObject * tmp_obj = SP_OBJECT(desktop->currentLayer()->appendChildRepr(tmp_node));
-        Inkscape::GC::release(tmp_node);
-        tmp_obj->updateRepr();
-        Geom::OptRect bounds = SP_ITEM(tmp_obj)->bounds(SPItem::GEOMETRIC_BBOX);
-        if (bounds) {
-            anotation_width = bounds->width();
-        }
-        tmp_obj->deleteObject();
+    } 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::createLine(Geom::Point start,Geom::Point end, Glib::ustring id, bool main, bool overflow, bool remove, bool arrows)
+LPEMeasureLine::doOnApply(SPLPEItem const* lpeitem)
 {
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + id).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        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 = SVGElemRef->getObject()) {
-            if (remove) {
-                elemref->deleteObject();
-                return;
-            }
-            line = elemref->getRepr();
-           
-            gchar * line_str = sp_svg_write_path( line_pathv );
-            line->setAttribute("d" , line_str);
-        } else {
-            if (remove) {
-                return;
-            }
-            line = xml_doc->createElement("svg:path");
-            line->setAttribute("id", id.c_str());
-            gchar * 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:" + (Glib::ustring)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:" + (Glib::ustring)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_OBJECT(desktop->currentLayer()->appendChildRepr(line));
-            Inkscape::GC::release(line);
-        }
+    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) {
-        SPDocument * doc = SP_ACTIVE_DOCUMENT;
-        Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem)->parent, SP_OBJECT(doc->getRoot()));
-        double parents_scale = (affinetransform.inverse().expansionX() + affinetransform.inverse().expansionY()) / 2.0;
-        
+        Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem), SP_OBJECT(document->getRoot()));
         Geom::PathVector pathvector = sp_path->get_original_curve()->get_pathvector();
-        pathvector *= affinetransform;
-        if (arrows_outside) {
-            createArrowMarker((Glib::ustring)"ArrowDINout-start");
-            createArrowMarker((Glib::ustring)"ArrowDINout-end");
-        } else {
-            createArrowMarker((Glib::ustring)"ArrowDIN-start");
-            createArrowMarker((Glib::ustring)"ArrowDIN-end");
+        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);
         }
-        if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-            if (((Glib::ustring)format.param_getSVGValue()).empty()) {
-                format.param_setValue((Glib::ustring)"{measure}{unit}");
-                this->upd_params = true;
+        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]);
             }
-            size_t ncurves = pathvector.curveCount();
-            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);
+            hstart[Geom::X] = xpos;
+            hend[Geom::X] = xpos;
+            if (hstart[Geom::Y] > hend[Geom::Y]) {
+                swap(hstart,hend);
+                swap(start,end);
             }
-            Geom::Point hstart = start;
-            Geom::Point hend = end;
-            bool remove = false;
-            if (Geom::are_near(hstart, hend)) {
+            if (Geom::are_near(hstart[Geom::Y], hend[Geom::Y])) {
                 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]);
             }
-            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;
-                }
+            hstart[Geom::Y] = ypos;
+            hend[Geom::Y] = ypos;
+            if (hstart[Geom::X] < hend[Geom::X]) {
+                swap(hstart,hend);
+                swap(start,end);
             }
-            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 (Geom::are_near(hstart[Geom::X], hend[Geom::X])) {
+                remove = true;
             }
-            //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 *= desktop->doc()->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);
+        }
+        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 (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);
-            }
-            if (scale_insensitive) {
-                length *= parents_scale;
+        }
+        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);
             }
-            createTextLabel(pos, length, angle, remove);
-            bool overflow = false;
-            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));
-                    }
+            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 {
-                    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));
-                    }
+                    prog_end = sstart + Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
                 }
-                overflow = true;
-                createLine(sstart, prog_end, (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), true, overflow, false, false);
             } else {
-                //erase it
-                createLine(Geom::Point(),Geom::Point(), (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), 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);
-            Glib::ustring id = (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id");
-            createLine(start, hstart, id, false, false, remove);
-            hend = hend - Point::polar(angle_cross, position);
-            id = (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id");
-            createLine(end, hend, id, false, false, remove);
-            if (!arrows_outside) {
-                hstart = hstart + Point::polar(angle, arrow_gap);
-                hend = hend - Point::polar(angle, arrow_gap );
+                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));
+                }
             }
-            id = (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id");
-            createLine(hstart, hend, id, true, overflow, remove, true);
+            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::doOnRemove (SPLPEItem const* lpeitem)
+void
+LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
 {
-    if (!erase) return;
-    
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        SPObject *elemref = NULL;
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->deleteObject();
-        }
-        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri2);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->deleteObject();
-        }
-        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri3);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->deleteObject();
-        }
-        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri4);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->deleteObject();
-        }
-        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri5);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->deleteObject();
-        }
+    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::toObjects()
+void 
+LPEMeasureLine::processObjects(LpeAction lpe_action)
 {
-    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
-        
-        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
-        SVGElemRef->attach(SVGElem_uri);
-        SPObject *elemref = NULL;
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
-        }
-        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri2);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
-        }
-        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri3);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+    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;
         }
-        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri4);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
-        }
-        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
-        SVGElemRef->attach(SVGElem_uri5);
-        if (elemref = SVGElemRef->getObject()) {
-            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
-        }
-        erase = false;
-        sp_lpe_item->removeCurrentPathEffect(true);
-        //TODO: find better way to refresh effect list
-        if (SP_IS_OBJECT(sp_lpe_item)){
-            Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
-            selection->remove(SP_OBJECT(sp_lpe_item));
-            selection->add(SP_OBJECT(sp_lpe_item));
+        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()
@@ -790,7 +746,6 @@ Gtk::Widget *LPEMeasureLine::newWidget()
 
     std::vector<Parameter *>::iterator it = param_vector.begin();
     Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
-    Gtk::HBox * button2 = 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);
@@ -822,16 +777,12 @@ Gtk::Widget *LPEMeasureLine::newWidget()
     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);
-    Gtk::Button *remove = Gtk::manage(new Gtk::Button(Glib::ustring(_("Convert to objects"))));
-    remove->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::toObjects));
-    button2->pack_start(*remove, 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);
-    vbox->pack_start(*button2, true, true, 2);
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -856,21 +807,21 @@ void
 LPEMeasureLine::saveDefault()
 {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setString("/live_effects/measure-line/fontbutton", (Glib::ustring)fontbutton.param_getSVGValue());
+    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->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_insensitive", scale_insensitive);
+    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);
diff --git a/src/live_effects/lpe-measure-line.h b/src/live_effects/lpe-measure-line.h
index 2fab9dbb9..c69921a4d 100644
--- a/src/live_effects/lpe-measure-line.h
+++ b/src/live_effects/lpe-measure-line.h
@@ -11,6 +11,9 @@
  */
 
 #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"
@@ -32,20 +35,27 @@ enum OrientationMethod {
     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 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 createLine(Geom::Point start,Geom::Point end,Glib::ustring id, bool main, bool overflow, bool remove, bool arrows = false);
-    void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove);
+    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 toObjects();
-    void createArrowMarker(Glib::ustring mode);
+    void createArrowMarker(const char * mode);
     void saveDefault();
     virtual Gtk::Widget *newWidget();
 private:
@@ -61,9 +71,10 @@ private:
     ScalarParam helpline_overlap;
     ScalarParam scale;
     TextParam format;
+    TextParam id_origin;
     BoolParam arrows_outside;
     BoolParam flip_side;
-    BoolParam scale_insensitive;
+    BoolParam scale_sensitive;
     BoolParam local_locale;
     BoolParam line_group_05;
     BoolParam rotate_anotation;
@@ -79,7 +90,9 @@ private:
     double fontsize;
     double anotation_width;
     double arrow_gap;
-    bool erase;
+    Geom::Point start_stored;
+    Geom::Point end_stored; 
+    std::vector<const char *> elements;
 /*    Geom::Affine affine_over;*/
     LPEMeasureLine(const LPEMeasureLine &);
     LPEMeasureLine &operator=(const LPEMeasureLine &);
diff --git a/src/live_effects/lpe-mirror_symmetry.cpp b/src/live_effects/lpe-mirror_symmetry.cpp
index 4deb29d8f..61b2b8b5c 100644
--- a/src/live_effects/lpe-mirror_symmetry.cpp
+++ b/src/live_effects/lpe-mirror_symmetry.cpp
@@ -13,13 +13,16 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
+
+#include <gtkmm.h>
 #include "live_effects/lpe-mirror_symmetry.h"
 #include <display/curve.h>
 #include <svg/path-string.h>
 #include "helper/geom.h"
 #include <2geom/path-intersection.h>
-#include "knotholder.h"
+
 // TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -34,39 +37,15 @@ static const Util::EnumData<ModeType> ModeTypeData[MT_END] = {
 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);
@@ -75,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;
 }
 
@@ -82,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());
@@ -99,47 +115,59 @@ 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;
 }
@@ -147,13 +175,12 @@ LPEMirrorSymmetry::doBeforeEffect (SPLPEItem const* lpeitem)
 void
 LPEMirrorSymmetry::transform_multiply(Geom::Affine const& postmul, bool set)
 {
-    center_point *= postmul;
-    previous_center = center_point;
     // 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
@@ -166,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;
 }
 
@@ -185,24 +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 cos = 0;
-    double sin = 0;
-    if (hyp > 0) {
-        cos = (point_b[0] - point_a[0]) / hyp;
-        sin = (point_b[1] - point_a[1]) / hyp;
-    }
-    Geom::Affine m2(cos, -sin, sin, cos, 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();
@@ -330,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 7ec4029e0..b4967173a 100644
--- a/src/live_effects/lpe-mirror_symmetry.h
+++ b/src/live_effects/lpe-mirror_symmetry.h
@@ -15,7 +15,7 @@
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
-#include <gtkmm.h>
+
 #include "live_effects/effect.h"
 #include "live_effects/parameter/parameter.h"
 #include "live_effects/parameter/point.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,
@@ -48,9 +43,7 @@ public:
     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);
@@ -62,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 a0fa46c3f..057f404e0 100644
--- a/src/live_effects/lpe-offset.cpp
+++ b/src/live_effects/lpe-offset.cpp
@@ -11,13 +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/elliptical-arc.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 9cd8ecf46..276749c43 100644
--- a/src/live_effects/lpe-parallel.cpp
+++ b/src/live_effects/lpe-parallel.cpp
@@ -11,14 +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 "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 8fbf9d420..a06dbde98 100644
--- a/src/live_effects/lpe-path_length.cpp
+++ b/src/live_effects/lpe-path_length.cpp
@@ -11,10 +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"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -37,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)
 {
@@ -69,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 0785da235..966e9020e 100644
--- a/src/live_effects/lpe-patternalongpath.cpp
+++ b/src/live_effects/lpe-patternalongpath.cpp
@@ -11,7 +11,10 @@
 #include <2geom/bezier-to-sbasis.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;
 
@@ -61,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),
@@ -142,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()){
@@ -159,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);
@@ -168,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) {
@@ -192,7 +198,7 @@ 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()){
+                    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());
@@ -208,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){        
@@ -232,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]);
@@ -261,7 +267,6 @@ LPEPatternAlongPath::transform_multiply(Geom::Affine const& postmul, bool set)
         pattern.param_transform_multiply(postmul, set);
         pattern.write_to_SVG();
     }
-    sp_lpe_item_update_patheffect (sp_lpe_item, false, true);
 }
 
 void
@@ -272,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 f69dae6a1..bce22250a 100644
--- a/src/live_effects/lpe-perp_bisector.cpp
+++ b/src/live_effects/lpe-perp_bisector.cpp
@@ -11,9 +11,6 @@
  *
  * 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"
@@ -21,6 +18,9 @@
 
 #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 6a6b59519..18b5b724d 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -20,6 +20,9 @@
 #include "display/curve.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 {
@@ -376,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);
@@ -405,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);
@@ -537,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 cb4e43d87..979b6dea5 100644
--- a/src/live_effects/lpe-perspective_path.cpp
+++ b/src/live_effects/lpe-perspective_path.cpp
@@ -11,8 +11,6 @@
  * 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-private.h"
@@ -20,9 +18,11 @@
 #include "live_effects/lpeobject.h"
 #include "knot-holder-entity.h"
 #include "knotholder.h"
-#include "desktop.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 {
 
@@ -242,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 329a00756..e9f3975c7 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -25,6 +25,9 @@
 #include <2geom/circle.h>
 #include "helper/geom.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
 
diff --git a/src/live_effects/lpe-recursiveskeleton.cpp b/src/live_effects/lpe-recursiveskeleton.cpp
index ed0c915ce..aa0db920b 100644
--- a/src/live_effects/lpe-recursiveskeleton.cpp
+++ b/src/live_effects/lpe-recursiveskeleton.cpp
@@ -10,12 +10,13 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glibmm/i18n.h>
-
 #include "live_effects/lpe-recursiveskeleton.h"
 
 #include <2geom/bezier-to-sbasis.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 2fb65b349..3cc8658ea 100644
--- a/src/live_effects/lpe-rough-hatches.cpp
+++ b/src/live_effects/lpe-rough-hatches.cpp
@@ -13,7 +13,6 @@
  */
 
 #include "ui/widget/scalar.h"
-#include <glibmm/i18n.h>
 #include "live_effects/lpe-rough-hatches.h"
 
 #include "sp-item.h"
@@ -23,6 +22,8 @@
 #include <2geom/sbasis-math.h>
 #include <2geom/bezier-to-sbasis.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 3a486ff10..c6edffd9b 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -13,11 +13,14 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <gtkmm.h>
 #include "live_effects/lpe-roughen.h"
 #include "display/curve.h"
 #include <boost/functional/hash.hpp>
 #include "helper/geom.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.h b/src/live_effects/lpe-roughen.h
index dbdb91e62..bab06022f 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -12,7 +12,6 @@
 #ifndef INKSCAPE_LPE_ROUGHEN_H
 #define INKSCAPE_LPE_ROUGHEN_H
 
-#include <gtkmm.h>
 #include "live_effects/effect.h"
 #include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/parameter.h"
diff --git a/src/live_effects/lpe-ruler.cpp b/src/live_effects/lpe-ruler.cpp
index 3a2d78b2c..60c2a3e1c 100644
--- a/src/live_effects/lpe-ruler.cpp
+++ b/src/live_effects/lpe-ruler.cpp
@@ -12,7 +12,8 @@
  */
 
 #include "live_effects/lpe-ruler.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 388ea176f..7c298d0e7 100644
--- a/src/live_effects/lpe-show_handles.cpp
+++ b/src/live_effects/lpe-show_handles.cpp
@@ -6,6 +6,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <gtkmm.h>
 #include "live_effects/lpe-show_handles.h"
 #include <2geom/sbasis-to-bezier.h>
 #include <2geom/svg-path-parser.h>
@@ -13,6 +14,7 @@
 #include "desktop-style.h"
 #include "style.h"
 #include "svg/svg.h"
+
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
@@ -24,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;
 }
 
@@ -129,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);
@@ -145,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) {
@@ -157,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 8bff3c1a8..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 <gtkmm.h>
+#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 ec21e10d2..5de9816bb 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -2,6 +2,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <gtkmm.h>
 #include "live_effects/lpe-simplify.h"
 #include "display/curve.h"
 #include "helper/geom.h"
@@ -9,6 +10,7 @@
 #include "svg/svg.h"
 #include "ui/tools/node-tool.h"
 #include "ui/icon-names.h"
+
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
@@ -138,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 8135561af..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 <gtkmm.h>
 #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 7d34db699..4fc18cee2 100644
--- a/src/live_effects/lpe-skeleton.cpp
+++ b/src/live_effects/lpe-skeleton.cpp
@@ -20,8 +20,7 @@
 
 #include "live_effects/lpe-skeleton.h"
 
-// You might need to include other 2geom files. You can add them here:
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
 namespace Inkscape {
@@ -98,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 95e2f6f0d..e01516f2e 100644
--- a/src/live_effects/lpe-sketch.cpp
+++ b/src/live_effects/lpe-sketch.cpp
@@ -13,13 +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/sbasis-math.h>
 #include <2geom/bezier-to-sbasis.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 4a41dc5a0..8ea57bee4 100644
--- a/src/live_effects/lpe-spiro.cpp
+++ b/src/live_effects/lpe-spiro.cpp
@@ -16,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 b308ef8d7..5f63e1ee9 100644
--- a/src/live_effects/lpe-tangent_to_curve.cpp
+++ b/src/live_effects/lpe-tangent_to_curve.cpp
@@ -13,13 +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 "knotholder.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -92,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 f6f6b33dc..f4a81aa90 100644
--- a/src/live_effects/lpe-taperstroke.cpp
+++ b/src/live_effects/lpe-taperstroke.cpp
@@ -26,6 +26,8 @@
 #include "svg/svg.h"
 
 #include "knotholder.h"
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
 
 template<typename T>
 inline bool withinRange(T value, T low, T high) {
@@ -433,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 c7ecf6481..324893706 100644
--- a/src/live_effects/lpe-test-doEffect-stack.cpp
+++ b/src/live_effects/lpe-test-doEffect-stack.cpp
@@ -4,10 +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"
 
+// 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 78db622f2..ef2900775 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -20,6 +20,7 @@
 // TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
+
 namespace Inkscape {
 namespace LivePathEffect {
 
@@ -33,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),
@@ -51,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);
@@ -72,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;
 }
 
@@ -378,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 2486f3366..47e2a1cec 100644
--- a/src/live_effects/lpe-vonkoch.cpp
+++ b/src/live_effects/lpe-vonkoch.cpp
@@ -5,7 +5,7 @@
  */
 
 #include "live_effects/lpe-vonkoch.h"
-
+// TODO due to internal breakage in glibmm headers, this must be last:
 #include <glibmm/i18n.h>
 
 //using std::vector;
diff --git a/src/live_effects/parameter/filletchamferpointarray.cpp b/src/live_effects/parameter/filletchamferpointarray.cpp
index b321a5831..7696288b0 100644
--- a/src/live_effects/parameter/filletchamferpointarray.cpp
+++ b/src/live_effects/parameter/filletchamferpointarray.cpp
@@ -24,7 +24,6 @@
 #include "selection.h"
 
 // needed for on-canvas editting:
-#include "desktop.h"
 #include "live_effects/lpeobject.h"
 #include "helper/geom-nodetype.h"
 #include "helper/geom-curves.h"
@@ -825,10 +824,7 @@ void FilletChamferPointArrayParamKnotHolderEntity::knot_set_offset(
     this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
 }
 
-void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
-        SPDesktop *desktop,
-        SPItem *item)
-{
+void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
     recalculate_knots(get_pwd2());
     for (unsigned int i = 0; i < _vector.size(); ++i) {
         if (_vector[i][Y] <= 0) {
@@ -854,7 +850,7 @@ void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
         }
         FilletChamferPointArrayParamKnotHolderEntity *e =
             new FilletChamferPointArrayParamKnotHolderEntity(this, i);
-        e->create(desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),
+        e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),
                   knot_shape, knot_mode, knot_color);
         knotholder->add(e);
     }
diff --git a/src/live_effects/parameter/filletchamferpointarray.h b/src/live_effects/parameter/filletchamferpointarray.h
index 48cd26d2d..b81339a69 100644
--- a/src/live_effects/parameter/filletchamferpointarray.h
+++ b/src/live_effects/parameter/filletchamferpointarray.h
@@ -59,8 +59,7 @@ public:
         return true;
     }
     virtual void updateCanvasIndicators();
-    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);
diff --git a/src/live_effects/parameter/fontbutton.cpp b/src/live_effects/parameter/fontbutton.cpp
index ff8ab76a0..64c203093 100644
--- a/src/live_effects/parameter/fontbutton.cpp
+++ b/src/live_effects/parameter/fontbutton.cpp
@@ -4,7 +4,7 @@
  * 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"
diff --git a/src/live_effects/parameter/fontbutton.h b/src/live_effects/parameter/fontbutton.h
index 387ad130b..df47251a2 100644
--- a/src/live_effects/parameter/fontbutton.h
+++ b/src/live_effects/parameter/fontbutton.h
@@ -8,7 +8,6 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 #include <glib.h>
-#include <gtkmm.h>
 #include "live_effects/parameter/parameter.h"
 
 namespace Inkscape {
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.h b/src/live_effects/parameter/parameter.h
index 3658bded8..6cf10710c 100644
--- a/src/live_effects/parameter/parameter.h
+++ b/src/live_effects/parameter/parameter.h
@@ -68,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*/) {};
@@ -118,6 +118,8 @@ public:
     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/point.cpp b/src/live_effects/parameter/point.cpp
index 3442fd851..c87b1e299 100644
--- a/src/live_effects/parameter/point.cpp
+++ b/src/live_effects/parameter/point.cpp
@@ -15,9 +15,6 @@
 #include "knotholder.h"
 #include <glibmm/i18n.h>
 
-// needed for on-canvas editting:
-#include "desktop.h"
-
 namespace Inkscape {
 
 namespace LivePathEffect {
@@ -126,9 +123,8 @@ PointParam::param_newWidget()
                                                               *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();
+    Geom::Affine transf = Geom::Scale(1, -1);
+    transf[5] = SP_ACTIVE_DOCUMENT->getHeight().value("px");
     _pointwdg->setTransform(transf);
     _pointwdg->setValue( *this );
     _pointwdg->clearProgrammatically();
@@ -205,12 +201,12 @@ PointParamKnotHolderEntity::knot_click(guint state)
 }
 
 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 62c6fb83d..e8cb66225 100644
--- a/src/live_effects/parameter/point.h
+++ b/src/live_effects/parameter/point.h
@@ -49,7 +49,7 @@ public:
     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:
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 0650b7e66..8cab68ad0 100644
--- a/src/live_effects/parameter/text.cpp
+++ b/src/live_effects/parameter/text.cpp
@@ -110,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 *
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&);