Update to trunk

(bzr r13645.1.174)

70 files changed, 766 insertions, 668 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 5ef9487ab..467a65c7c 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -73,8 +73,10 @@
 #include "path-chemistry.h"
 #include "xml/sp-css-attr.h"
 #include "live_effects/lpeobject.h"
+#include <pangomm/layout.h>
 #include "display/curve.h"
-
+#include <stdio.h>
+#include <string.h>
 
 namespace Inkscape {
 
@@ -83,63 +85,63 @@ namespace LivePathEffect {
 const Util::EnumData<EffectType> LPETypeData[] = {
     // {constant defined in effect-enum.h, N_("name of your effect"), "name of your effect in SVG"}
 #ifdef LPE_ENABLE_TEST_EFFECTS
-    {DOEFFECTSTACK_TEST,    N_("doEffect stack test"),     "doeffectstacktest"},
-    {ANGLE_BISECTOR,        N_("Angle bisector"),          "angle_bisector"},
+    {DOEFFECTSTACK_TEST,    N_("doEffect stack test"),             "doeffectstacktest"},
+    {ANGLE_BISECTOR,        N_("Angle bisector"),                  "angle_bisector"},
     {CIRCLE_WITH_RADIUS,    N_("Circle (by center and radius)"),   "circle_with_radius"},
-    {CIRCLE_3PTS,           N_("Circle by 3 points"),      "circle_3pts"},
-    {DYNASTROKE,            N_("Dynamic stroke"),          "dynastroke"},
-    {EXTRUDE,               N_("Extrude"),                 "extrude"},
-    {LATTICE,               N_("Lattice Deformation"),     "lattice"},
-    {LINE_SEGMENT,          N_("Line Segment"),            "line_segment"},
-    {OFFSET,                N_("Offset"),                  "offset"},
-    {PARALLEL,              N_("Parallel"),                "parallel"},
-    {PATH_LENGTH,           N_("Path length"),             "path_length"},
-    {PERP_BISECTOR,         N_("Perpendicular bisector"),  "perp_bisector"},
-    {PERSPECTIVE_PATH,      N_("Perspective path"),        "perspective_path"},
-    {RECURSIVE_SKELETON,    N_("Recursive skeleton"),      "recursive_skeleton"},
-    {TANGENT_TO_CURVE,      N_("Tangent to curve"),        "tangent_to_curve"},
-    {TEXT_LABEL,            N_("Text label"),              "text_label"},
+    {CIRCLE_3PTS,           N_("Circle by 3 points"),              "circle_3pts"},
+    {DYNASTROKE,            N_("Dynamic stroke"),                  "dynastroke"},
+    {EXTRUDE,               N_("Extrude"),                         "extrude"},
+    {LATTICE,               N_("Lattice Deformation"),             "lattice"},
+    {LINE_SEGMENT,          N_("Line Segment"),                    "line_segment"},
+    {OFFSET,                N_("Offset"),                          "offset"},
+    {PARALLEL,              N_("Parallel"),                        "parallel"},
+    {PATH_LENGTH,           N_("Path length"),                     "path_length"},
+    {PERP_BISECTOR,         N_("Perpendicular bisector"),          "perp_bisector"},
+    {PERSPECTIVE_PATH,      N_("Perspective path"),                "perspective_path"},
+    {RECURSIVE_SKELETON,    N_("Recursive skeleton"),              "recursive_skeleton"},
+    {TANGENT_TO_CURVE,      N_("Tangent to curve"),                "tangent_to_curve"},
+    {TEXT_LABEL,            N_("Text label"),                      "text_label"},
 #endif
 /* 0.46 */
-    {BEND_PATH,             N_("Bend"),                    "bend_path"},
-    {GEARS,                 N_("Gears"),                   "gears"},
-    {PATTERN_ALONG_PATH,    N_("Pattern Along Path"),      "skeletal"},   // for historic reasons, this effect is called skeletal(strokes) in Inkscape:SVG
-    {CURVE_STITCH,          N_("Stitch Sub-Paths"),        "curvestitching"},
+    {BEND_PATH,             N_("Bend"),                            "bend_path"},
+    {GEARS,                 N_("Gears"),                           "gears"},
+    {PATTERN_ALONG_PATH,    N_("Pattern Along Path"),              "skeletal"},   // for historic reasons, this effect is called skeletal(strokes) in Inkscape:SVG
+    {CURVE_STITCH,          N_("Stitch Sub-Paths"),                "curvestitching"},
 /* 0.47 */
-    {VONKOCH,               N_("VonKoch"),                 "vonkoch"},
-    {KNOT,                  N_("Knot"),                    "knot"},
-    {CONSTRUCT_GRID,        N_("Construct grid"),          "construct_grid"},
-    {SPIRO,                 N_("Spiro spline"),            "spiro"},
-    {ENVELOPE,              N_("Envelope Deformation"),    "envelope"},
-    {INTERPOLATE,           N_("Interpolate Sub-Paths"),   "interpolate"},
-    {ROUGH_HATCHES,         N_("Hatches (rough)"),         "rough_hatches"},
-    {SKETCH,                N_("Sketch"),                  "sketch"},
-    {RULER,                 N_("Ruler"),                   "ruler"},
+    {VONKOCH,               N_("VonKoch"),                         "vonkoch"},
+    {KNOT,                  N_("Knot"),                            "knot"},
+    {CONSTRUCT_GRID,        N_("Construct grid"),                  "construct_grid"},
+    {SPIRO,                 N_("Spiro spline"),                    "spiro"},
+    {ENVELOPE,              N_("Envelope Deformation"),            "envelope"},
+    {INTERPOLATE,           N_("Interpolate Sub-Paths"),           "interpolate"},
+    {ROUGH_HATCHES,         N_("Hatches (rough)"),                 "rough_hatches"},
+    {SKETCH,                N_("Sketch"),                          "sketch"},
+    {RULER,                 N_("Ruler"),                           "ruler"},
 /* 0.91 */
-    {POWERSTROKE,           N_("Power stroke"),            "powerstroke"},
-    {CLONE_ORIGINAL,        N_("Clone original"),          "clone_original"},
+    {POWERSTROKE,           N_("Power stroke"),                    "powerstroke"},
+    {CLONE_ORIGINAL,        N_("Clone original"),                  "clone_original"},
 /* 0.92 */
-    {SIMPLIFY,              N_("Simplify"),                "simplify"},
-    {LATTICE2,              N_("Lattice Deformation 2"),   "lattice2"},
-    {PERSPECTIVE_ENVELOPE,  N_("Perspective/Envelope"),    "perspective_envelope"},
-    {INTERPOLATE_POINTS,    N_("Interpolate points"),      "interpolate_points"},
-    {TRANSFORM_2PTS,        N_("Transform by 2 points"),   "transform_2pts"},
-    {SHOW_HANDLES,          N_("Show handles"),            "show_handles"},
-    {ROUGHEN,               N_("Roughen"),                 "roughen"},
-    {BSPLINE,               N_("BSpline"),                 "bspline"},
-    {JOIN_TYPE,             N_("Join type"),               "join_type"},
-    {TAPER_STROKE,          N_("Taper stroke"),            "taper_stroke"},
-    {MIRROR_SYMMETRY,       N_("Mirror symmetry"),         "mirror_symmetry"},
-    {COPY_ROTATE,           N_("Rotate copies"),           "copy_rotate"},
+    {SIMPLIFY,              N_("Simplify"),                        "simplify"},
+    {LATTICE2,              N_("Lattice Deformation 2"),           "lattice2"},
+    {PERSPECTIVE_ENVELOPE,  N_("Perspective/Envelope"),            "perspective-envelope"}, //TODO:Wrong name with "-"
+    {INTERPOLATE_POINTS,    N_("Interpolate points"),              "interpolate_points"},
+    {TRANSFORM_2PTS,        N_("Transform by 2 points"),           "transform_2pts"},
+    {SHOW_HANDLES,          N_("Show handles"),                    "show_handles"},
+    {ROUGHEN,               N_("Roughen"),                         "roughen"},
+    {BSPLINE,               N_("BSpline"),                         "bspline"},
+    {JOIN_TYPE,             N_("Join type"),                       "join_type"},
+    {TAPER_STROKE,          N_("Taper stroke"),                    "taper_stroke"},
+    {MIRROR_SYMMETRY,       N_("Mirror symmetry"),                 "mirror_symmetry"},
+    {COPY_ROTATE,           N_("Rotate copies"),                   "copy_rotate"},
 /* Ponyscape -> Inkscape 0.92*/
-    {ATTACH_PATH,           N_("Attach path"),             "attach_path"},
-    {FILL_BETWEEN_STROKES,  N_("Fill between strokes"),    "fill_between_strokes"},
-    {FILL_BETWEEN_MANY,     N_("Fill between many"),       "fill_between_many"},
-    {ELLIPSE_5PTS,          N_("Ellipse by 5 points"),     "ellipse_5pts"},
-    {BOUNDING_BOX,          N_("Bounding Box"),            "bounding_box"},
+    {ATTACH_PATH,           N_("Attach path"),                     "attach_path"},
+    {FILL_BETWEEN_STROKES,  N_("Fill between strokes"),            "fill_between_strokes"},
+    {FILL_BETWEEN_MANY,     N_("Fill between many"),               "fill_between_many"},
+    {ELLIPSE_5PTS,          N_("Ellipse by 5 points"),             "ellipse_5pts"},
+    {BOUNDING_BOX,          N_("Bounding Box"),                    "bounding_box"},
 /* 9.93 */
-    {MEASURE_LINE,          N_("Measure Line"),            "measure_line"},
-    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),          "fillet_chamfer"},
+    {MEASURE_LINE,          N_("Measure Line"),                    "measure_line"},
+    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -401,58 +403,19 @@ Effect::setCurrentZoom(double cZ)
 }
 
 void
-Effect::setSelectedNodePos(std::vector<Geom::Point> selected_nodes_pos_data)
+Effect::setSelectedNodePoints(std::vector<Geom::Point> sNP)
 {
-    selected_nodes_pos = selected_nodes_pos_data;
-}
-
-void
-
-Effect::setSelectedNodeIndex(Geom::PathVector pv)
-{
-    selected_nodes_index.clear();
-    for (Geom::PathVector::const_iterator path_it = pv.begin();
-            path_it != pv.end(); ++path_it) {
-
-        if (path_it->empty()) {
-            continue;
-        }
-        Geom::Path::const_iterator curve_it1 = path_it->begin();
-        Geom::Path::const_iterator curve_endit = path_it->end_default();
-        if (path_it->closed()) {
-          const Geom::Curve &closingline = path_it->back_closed(); 
-          // the closing line segment is always of type 
-          // Geom::LineSegment.
-          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
-            // closingline.isDegenerate() did not work, because it only checks for
-            // *exact* zero length, which goes wrong for relative coordinates and
-            // rounding errors...
-            // the closing line segment has zero-length. So stop before that one!
-            curve_endit = path_it->end_open();
-          }
-        }
-        size_t i = 0;
-        while (curve_it1 != curve_endit) {
-            if (isNodeSelected(curve_it1->initialPoint())) {
-                selected_nodes_index.push_back(i);
-            }
-            ++i;
-            ++curve_it1;
-        }
-        if (isNodeSelected(path_it->finalPoint())) {
-            selected_nodes_index.push_back(i);
-        }
-    }
+    selectedNodesPoints = sNP;
 }
 
 bool
-Effect::isNodeSelected(Geom::Point const &nodePoint) const
+Effect::isNodePointSelected(Geom::Point const &nodePoint) const
 {
-    if (selected_nodes_pos.size() > 0) {
+    if (selectedNodesPoints.size() > 0) {
         using Geom::X;
         using Geom::Y; 
-        for (std::vector<Geom::Point>::const_iterator i = selected_nodes_pos.begin();
-                i != selected_nodes_pos.end(); ++i) {
+        for (std::vector<Geom::Point>::const_iterator i = selectedNodesPoints.begin();
+                i != selectedNodesPoints.end(); ++i) {
             Geom::Point p = *i;
             Geom::Affine transformCoordinate = sp_lpe_item->i2dt_affine();
             Geom::Point p2(nodePoint[X],nodePoint[Y]);
@@ -683,6 +646,7 @@ void
 Effect::readallParameters(Inkscape::XML::Node const* repr)
 {
     std::vector<Parameter *>::iterator it = param_vector.begin();
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     while (it != param_vector.end()) {
         Parameter * param = *it;
         const gchar * key = param->param_key.c_str();
@@ -693,10 +657,17 @@ Effect::readallParameters(Inkscape::XML::Node const* repr)
                 g_warning("Effect::readallParameters - '%s' not accepted for %s", value, key);
             }
         } else {
-            // set default value
-            param->param_set_default();
+            Glib::ustring pref_path = (Glib::ustring)"/live_effects/" +
+                                       (Glib::ustring)LPETypeConverter.get_key(effectType()).c_str() +
+                                       (Glib::ustring)"/" + 
+                                       (Glib::ustring)key;
+            bool valid = prefs->getEntry(pref_path).isValid();
+            if(valid){
+                param->param_update_default(prefs->getString(pref_path).c_str());
+            } else {
+                param->param_set_default();
+            }
         }
-
         ++it;
     }
 }
@@ -811,10 +782,96 @@ Effect::newWidget()
 
         ++it;
     }
-    upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
+/**
+ * This *creates* a new widget, with default values setter
+ */
+Gtk::Widget *
+Effect::defaultParamSet()
+{
+    // use manage here, because after deletion of Effect object, others might still be pointing to this widget.
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    Gtk::VBox * vbox = Gtk::manage( new Gtk::VBox() );
+    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox() );
+    Glib::ustring effectname = (Glib::ustring)Inkscape::LivePathEffect::LPETypeConverter.get_label(effectType());
+    Glib::ustring effectkey = (Glib::ustring)Inkscape::LivePathEffect::LPETypeConverter.get_key(effectType());
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    Inkscape::UI::Widget::Registry * wr;
+    bool has_params = false;
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            has_params = true;
+            Parameter * param = *it;
+            Glib::ustring * tip = param->param_getTooltip();
+            const gchar * key = param->param_key.c_str();
+            const gchar * value = param->param_label.c_str();
+            const gchar * tooltip_extra = _(". Change custom values for this parameter");
+            Glib::ustring tooltip = param->param_tooltip + (Glib::ustring)tooltip_extra;
+            Glib::ustring pref_path = (Glib::ustring)"/live_effects/" +
+                                       effectkey +
+                                      (Glib::ustring)"/" + 
+                                      (Glib::ustring)key;
+            bool valid = prefs->getEntry(pref_path).isValid();
+            const gchar * set_or_upd;
+            if (valid) {
+                set_or_upd = _("Update");
+            } else {
+                set_or_upd = _("Set");
+            }
+            Gtk::HBox * vbox_param = Gtk::manage( new Gtk::HBox(true) );
+            Gtk::Label *parameter_label = Gtk::manage(new Gtk::Label(value, Gtk::ALIGN_START));
+            parameter_label->set_use_markup(true);
+            parameter_label->set_use_underline (true);
+            parameter_label->set_ellipsize(Pango::ELLIPSIZE_END);
+            vbox_param->pack_start(*parameter_label, true, true, 2);
+            Gtk::Button *set = Gtk::manage(new Gtk::Button((Glib::ustring)set_or_upd));
+            Gtk::Button *unset = Gtk::manage(new Gtk::Button(Glib::ustring(_("Unset"))));
+            unset->signal_clicked().connect(sigc::bind<Glib::ustring, Gtk::Button *, Gtk::Button *>(sigc::mem_fun(*this, &Effect::unsetDefaultParam), pref_path, set, unset));
+            set->signal_clicked().connect(sigc::bind<Glib::ustring, gchar *, Gtk::Button *, Gtk::Button *>(sigc::mem_fun(*this, &Effect::setDefaultParam), pref_path, param->param_getSVGValue(), set, unset));
+            if (!valid) {
+                unset->set_sensitive(false);
+            }
+            vbox_param->pack_start(*set, true, true, 2);
+            vbox_param->pack_start(*unset, true, true, 2);
+
+            vbox_expander->pack_start(*vbox_param, true, true, 2);
+        }
+        ++it;
+    }
+    Glib::ustring tip = "<b>" + effectname + (Glib::ustring)_("</b>: Set default parameters");
+    Gtk::Expander * expander = Gtk::manage(new Gtk::Expander(tip));
+    expander->set_use_markup(true);
+    expander->add(*vbox_expander);
+    expander->set_expanded(false);
+    vbox->pack_start(*dynamic_cast<Gtk::Widget *> (expander), true, true, 2);
+    if (has_params) {
+        return dynamic_cast<Gtk::Widget *>(vbox);
+    } else {
+        return NULL;
+    }
+}
+
+void
+Effect::setDefaultParam(Glib::ustring pref_path, gchar * value, Gtk::Button *set , Gtk::Button *unset)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setString(pref_path, (Glib::ustring)value);
+    gchar * label = _("Update");
+    set->set_label((Glib::ustring)label);
+    unset->set_sensitive(true);
+}
+
+void
+Effect::unsetDefaultParam(Glib::ustring pref_path, Gtk::Button *set, Gtk::Button *unset)
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->remove(pref_path);
+    gchar * label = _("Set");
+    set->set_label((Glib::ustring)label);
+    unset->set_sensitive(false);
+}
 
 Inkscape::XML::Node *Effect::getRepr()
 {
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index 6c11e0b67..c34c391c0 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -65,9 +65,8 @@ public:
     void doOnApply_impl(SPLPEItem const* lpeitem);
     void doBeforeEffect_impl(SPLPEItem const* lpeitem);
     void setCurrentZoom(double cZ);
-    void setSelectedNodePos(std::vector<Geom::Point> selected_nodes_pos_data);
-    void setSelectedNodeIndex(Geom::PathVector pv);
-    bool isNodeSelected(Geom::Point const &nodePoint) const;
+    void setSelectedNodePoints(std::vector<Geom::Point> sNP);
+    bool isNodePointSelected(Geom::Point const &nodePoint) const;
     virtual void doOnApply (SPLPEItem const* lpeitem);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
     
@@ -95,7 +94,7 @@ public:
     virtual void doEffect (SPCurve * curve);
 
     virtual Gtk::Widget * newWidget();
-
+    virtual Gtk::Widget * defaultParamSet();
     /**
      * Sets all parameters to their default values and writes them to SVG.
      */
@@ -173,14 +172,15 @@ protected:
     // this boolean defaults to false, it concatenates the input path to one pwd2,
     // instead of normally 'splitting' the path into continuous pwd2 paths and calling doEffect_pwd2 for each.
     bool concatenate_before_pwd2;
-
     SPLPEItem * sp_lpe_item; // these get stored in doBeforeEffect_impl, and derived classes may do as they please with them.
     SPShape * sp_shape; // these get stored in doBeforeEffect_impl before doEffect chain, or in performPathEffects on groups, and derived classes may do as they please with them.
     std::vector<const char *> items;
     double current_zoom;
-    std::vector<Geom::Point> selected_nodes_pos;
-    std::vector<size_t> selected_nodes_index;
+    std::vector<Geom::Point> selectedNodesPoints;
+
 private:
+    void setDefaultParam(Glib::ustring pref_path, gchar * value, Gtk::Button *set , Gtk::Button *unset);
+    void unsetDefaultParam(Glib::ustring pref_path, Gtk::Button *set , Gtk::Button *unset);
     bool provides_own_flash_paths; // if true, the standard flash path is suppressed
 
     bool is_ready;
diff --git a/src/live_effects/lpe-bendpath.cpp b/src/live_effects/lpe-bendpath.cpp
index b1e133292..363356cac 100644
--- a/src/live_effects/lpe-bendpath.cpp
+++ b/src/live_effects/lpe-bendpath.cpp
@@ -57,10 +57,10 @@ LPEBendPath::LPEBendPath(LivePathEffectObject *lpeobject) :
     scale_y_rel(_("W_idth in units of length"), _("Scale the width of the path in units of its length"), "scale_y_rel", &wr, this, false),
     vertical_pattern(_("_Original path is vertical"), _("Rotates the original 90 degrees, before bending it along the bend path"), "vertical", &wr, this, false)
 {
-    registerParameter( dynamic_cast<Parameter *>(&bend_path) );
-    registerParameter( dynamic_cast<Parameter *>(&prop_scale) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_y_rel) );
-    registerParameter( dynamic_cast<Parameter *>(&vertical_pattern) );
+    registerParameter( &bend_path );
+    registerParameter( &prop_scale);
+    registerParameter( &scale_y_rel);
+    registerParameter( &vertical_pattern);
 
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
diff --git a/src/live_effects/lpe-bounding-box.cpp b/src/live_effects/lpe-bounding-box.cpp
index 11fb34e04..c83d7e3bc 100644
--- a/src/live_effects/lpe-bounding-box.cpp
+++ b/src/live_effects/lpe-bounding-box.cpp
@@ -20,8 +20,8 @@ LPEBoundingBox::LPEBoundingBox(LivePathEffectObject *lpeobject) :
     linked_path(_("Linked path:"), _("Path from which to take the original path data"), "linkedpath", &wr, this),
     visual_bounds(_("Visual Bounds"), _("Uses the visual bounding box"), "visualbounds", &wr, this)
 {
-    registerParameter( dynamic_cast<Parameter *>(&linked_path) );
-    registerParameter( dynamic_cast<Parameter *>(&visual_bounds) );
+    registerParameter(&linked_path);
+    registerParameter(&visual_bounds);
     //perceived_path = true;
 }
 
diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index 3fed11d5a..5c227e68a 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -86,7 +86,7 @@ Gtk::Widget *LPEBSpline::newWidget()
     // use manage here, because after deletion of Effect object, others might
     // still be pointing to this widget.
     Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
-
+    vbox->set_homogeneous(false);
     vbox->set_border_width(5);
     std::vector<Parameter *>::iterator it = param_vector.begin();
     while (it != param_vector.end()) {
@@ -398,7 +398,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount)
                     (apply_no_weight && Geom::are_near((*cubic)[1], point_at0)) ||
                     (apply_with_weight && !Geom::are_near((*cubic)[1], point_at0)))
                 {
-                    if (isNodeSelected(point_at0) || !only_selected) {
+                    if (isNodePointSelected(point_at0) || !only_selected) {
                         point_at1 = sbasis_in.valueAt(weight_ammount);
                         if (weight_ammount != NO_POWER) {
                             point_at1 =
@@ -414,7 +414,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount)
                     (apply_no_weight && Geom::are_near((*cubic)[2], point_at3)) ||
                     (apply_with_weight && !Geom::are_near((*cubic)[2], point_at3)))
                 {
-                    if (isNodeSelected(point_at3) || !only_selected) {
+                    if (isNodePointSelected(point_at3) || !only_selected) {
                         point_at2 = sbasis_in.valueAt(1 - weight_ammount);
                         if (weight_ammount != NO_POWER) {
                             point_at2 =
@@ -431,14 +431,14 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount)
                     (apply_no_weight && weight_ammount == NO_POWER) ||
                     (apply_with_weight && weight_ammount != NO_POWER))
                 {
-                    if (isNodeSelected(point_at0) || !only_selected) {
+                    if (isNodePointSelected(point_at0) || !only_selected) {
                         point_at1 = sbasis_in.valueAt(weight_ammount);
                         point_at1 =
                             Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
                     } else {
                         point_at1 = in->first_segment()->initialPoint();
                     }
-                    if (isNodeSelected(point_at3) || !only_selected) {
+                    if (isNodePointSelected(point_at3) || !only_selected) {
                         point_at2 = sbasis_in.valueAt(1 - weight_ammount);
                         point_at2 =
                             Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
diff --git a/src/live_effects/lpe-clone-original.cpp b/src/live_effects/lpe-clone-original.cpp
index c41b1ef95..d97a990af 100644
--- a/src/live_effects/lpe-clone-original.cpp
+++ b/src/live_effects/lpe-clone-original.cpp
@@ -20,8 +20,7 @@ namespace LivePathEffect {
 
 LPECloneOriginal::LPECloneOriginal(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
-    linked_path("LEGACY FALLBACK", "LEGACY FALLBACK", "linkedpath", &wr, this),
-    linked_item(_("Linked Item:"), _("Item from which to take the original data"), "linked_item", &wr, this),
+    linkeditem(_("Linked Item:"), _("Item from which to take the original data"), "linkeditem", &wr, this),
     scale(_("Scale %"), _("Scale item %"), "scale", &wr, this, 100.0),
     preserve_position(_("Preserve position"), _("Preserve position"), "preserve_position", &wr, this, false),
     inverse(_("Inverse clone"), _("Use LPE item as origin"), "inverse", &wr, this, false),
@@ -37,8 +36,15 @@ LPECloneOriginal::LPECloneOriginal(LivePathEffectObject *lpeobject) :
     expanded(false),
     origin(Geom::Point(0,0))
 {
-    registerParameter(&linked_path);
-    registerParameter(&linked_item);
+    //0.92 compatibility
+    const gchar * linkedpath = this->getRepr()->attribute("linkedpath");
+    if (linkedpath && strcmp(linkedpath, "") != 0){
+        this->getRepr()->setAttribute("linkeditem", linkedpath);
+        this->getRepr()->setAttribute("linkedpath", NULL);
+        this->getRepr()->setAttribute("transform", "false");
+    };
+
+    registerParameter(&linkeditem);
     registerParameter(&scale);
     registerParameter(&attributes);
     registerParameter(&style_attributes);
@@ -208,19 +214,8 @@ LPECloneOriginal::cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, co
 
 void
 LPECloneOriginal::doBeforeEffect (SPLPEItem const* lpeitem){
-    if (linked_path.linksToPath()) { //Legacy staff
-        Glib::ustring attributes_value("d");
-        attributes.param_setValue(attributes_value);
-        attributes.write_to_SVG();
-        Glib::ustring style_attributes_value("");
-        style_attributes.param_setValue(style_attributes_value);
-        style_attributes.write_to_SVG();
-        linked_item.param_readSVGValue(linked_path.param_getSVGValue());
-        linked_path.param_readSVGValue("");
-    }
-
-    if (linked_item.linksToItem()) {
-        linked_item.setInverse(inverse);
+    if (linkeditem.linksToItem()) {
+        linkeditem.setInverse(inverse);
         if ( preserve_position_changed != preserve_position ) {
             if (!preserve_position) {
                 sp_svg_transform_read(SP_ITEM(sp_lpe_item)->getAttribute("transform"), &preserve_affine);
@@ -262,8 +257,8 @@ LPECloneOriginal::doBeforeEffect (SPLPEItem const* lpeitem){
         }
         style_attr.append(Glib::ustring(style_attributes.param_getSVGValue()).append(","));
 
-        SPItem * from =  inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linked_item.getObject()); 
-        SPItem * to   = !inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linked_item.getObject()); 
+        SPItem * from =  inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linkeditem.getObject()); 
+        SPItem * to   = !inverse ? SP_ITEM(sp_lpe_item) : SP_ITEM(linkeditem.getObject()); 
         cloneAttrbutes(from, to, true, g_strdup(attr.c_str()), g_strdup(style_attr.c_str()), true);
         Geom::OptRect bbox = from->geometricBounds();
         if (bbox && preserve_position && origin != Geom::Point(0,0)) {
@@ -323,7 +318,6 @@ LPECloneOriginal::newWidget()
     expander->set_expanded(expanded);
     expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPECloneOriginal::onExpanderChanged) );
     vbox->pack_start(*expander, true, true, 2);
-    this->upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -346,15 +340,15 @@ LPECloneOriginal::~LPECloneOriginal()
 void
 LPECloneOriginal::transform_multiply(Geom::Affine const& postmul, bool set)
 {
-    if (linked_item.linksToItem()) {
-        linked_item.getObject()->requestModified(SP_OBJECT_MODIFIED_FLAG);
+    if (linkeditem.linksToItem()) {
+        linkeditem.getObject()->requestModified(SP_OBJECT_MODIFIED_FLAG);
     }
 }
 
 void 
 LPECloneOriginal::doEffect (SPCurve * curve)
 {
-    if (linked_item.linksToItem() && !inverse) {
+    if (linkeditem.linksToItem() && !inverse) {
         SPShape * shape = getCurrentShape();
         if(shape){
             curve->set_pathvector(shape->getCurve()->get_pathvector());
diff --git a/src/live_effects/lpe-clone-original.h b/src/live_effects/lpe-clone-original.h
index e4328c169..9bab8553f 100644
--- a/src/live_effects/lpe-clone-original.h
+++ b/src/live_effects/lpe-clone-original.h
@@ -32,8 +32,7 @@ public:
     void cloneAttrbutes(SPObject *origin, SPObject *dest, bool live, const char * attributes, const char * style_attributes, bool root);
 
 private:
-    OriginalPathParam  linked_path;
-    OriginalItemParam  linked_item;
+    OriginalItemParam  linkeditem;
     ScalarParam scale;
     BoolParam preserve_position;
     BoolParam inverse;
diff --git a/src/live_effects/lpe-constructgrid.cpp b/src/live_effects/lpe-constructgrid.cpp
index 8d24f9f47..db620fa95 100644
--- a/src/live_effects/lpe-constructgrid.cpp
+++ b/src/live_effects/lpe-constructgrid.cpp
@@ -24,8 +24,8 @@ LPEConstructGrid::LPEConstructGrid(LivePathEffectObject *lpeobject) :
     nr_x(_("Size _X:"), _("The size of the grid in X direction."), "nr_x", &wr, this, 5),
     nr_y(_("Size _Y:"), _("The size of the grid in Y direction."), "nr_y", &wr, this, 5)
 {
-    registerParameter( dynamic_cast<Parameter *>(&nr_x) );
-    registerParameter( dynamic_cast<Parameter *>(&nr_y) );
+    registerParameter(&nr_x);
+    registerParameter(&nr_y);
 
     nr_x.param_make_integer();
     nr_y.param_make_integer();
diff --git a/src/live_effects/lpe-copy_rotate.cpp b/src/live_effects/lpe-copy_rotate.cpp
index bf82b5deb..ffd2ef4cf 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -30,6 +30,14 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+static const Util::EnumData<RotateMethod> RotateMethodData[RM_END] = {
+    { RM_NORMAL, N_("Normal"), "normal" },
+    { RM_KALEIDOSCOPE, N_("Kaleidoscope"), "kaleidoskope" },
+    { RM_FUSE, N_("Fuse paths"), "fuse_paths" }
+};
+static const Util::EnumDataConverter<RotateMethod>
+RMConverter(RotateMethodData, RM_END);
+
 bool 
 pointInTriangle(Geom::Point const &p, Geom::Point const &p1, Geom::Point const &p2, Geom::Point const &p3)
 {
@@ -52,30 +60,37 @@ LPECopyRotate::LPECopyRotate(LivePathEffectObject *lpeobject) :
     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),
-    split_gap(_("Gap on split"), _("Gap on split"), "split_gap", &wr, this, -0.001),
+    gap(_("Gap"), _("Gap"), "gap", &wr, this, -0.0001),
     copies_to_360(_("360º Copies"), _("No rotation angle, fixed to 360º"), "copies_to_360", &wr, this, true),
-    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),
+    method(_("Method:"), _("Rotate methods"), "method", RMConverter, &wr, this, RM_NORMAL),
+    mirror_copies(_("Mirror copies"), _("Mirror between copies"), "mirror_copies", &wr, this, false),
     split_items(_("Split elements"), _("Split elements, this allow gradients and other paints."), "split_items", &wr, this, false),
     dist_angle_handle(100.0)
 {
     show_orig_path = true;
     _provides_knotholder_entities = true;
+    //0.92 compatibility
+    if (this->getRepr()->attribute("fuse_paths") && strcmp(this->getRepr()->attribute("fuse_paths"), "true") == 0){
+        this->getRepr()->setAttribute("fuse_paths", NULL);
+        this->getRepr()->setAttribute("method", "kaleidoskope");
+        this->getRepr()->setAttribute("mirror_copies", "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(&split_items);
+    registerParameter(&method);
+    registerParameter(&num_copies);
     registerParameter(&starting_angle);
     registerParameter(&starting_point);
     registerParameter(&rotation_angle);
-    registerParameter(&num_copies);
-    registerParameter(&split_gap);
+    registerParameter(&gap);
     registerParameter(&origin);
-    split_gap.param_set_range(-999999.0, 999999.0);
-    split_gap.param_set_increments(0.1, 0.1);
-    split_gap.param_set_digits(5);
-    num_copies.param_set_range(0, 999999);
+    registerParameter(&copies_to_360);
+    registerParameter(&mirror_copies);
+    registerParameter(&split_items);
+
+    gap.param_set_range(-99999.0, 99999.0);
+    gap.param_set_increments(0.1, 0.1);
+    gap.param_set_digits(5);
+    num_copies.param_set_range(1, 999999);
     num_copies.param_make_integer(true);
     apply_to_clippath_and_mask = true;
     previous_num_copies = num_copies;
@@ -132,38 +147,21 @@ LPECopyRotate::doAfterEffect (SPLPEItem const* lpeitem)
             counter++;
         }
         g_free(id);
-        double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
-        Geom::Rect bbox(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
-        double size_divider = Geom::distance(origin,bbox) + (diagonal * 2);
-        Geom::Point line_start  = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(starting_angle))) * size_divider;
-        Geom::Point line_end = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(rotation_angle + starting_angle))) * size_divider;
         Geom::Affine m = Geom::Translate(-origin) * Geom::Rotate(-(Geom::rad_from_deg(starting_angle)));
-        if (fuse_paths) {
-            size_t rest = 0;
-            for (size_t i = 1; i < num_copies; ++i) {
-                Geom::Affine r = Geom::identity();
-                Geom::Point dir = unit_vector((Geom::Point)origin - Geom::middle_point(line_start,line_end));
-                if( rest%2 == 0) {
-                    r *= Geom::Rotate(Geom::Angle(dir)).inverse();
-                    r *= Geom::Scale(1, -1);
-                    r *= Geom::Rotate(Geom::Angle(dir));
-                }
-                Geom::Rotate rot(-(Geom::rad_from_deg(rotation_angle * i)));
-                Geom::Affine t = m * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)) * Geom::Translate(origin);
-                if( rest%2 == 0) {
-                    t = m * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)).inverse() * Geom::Translate(origin);
-                }
-                t *= sp_lpe_item->transform;
-                toItem(t, i-1, reset);
-                rest ++;
+        for (size_t i = 1; i < num_copies; ++i) {
+            Geom::Affine r = Geom::identity();
+            if( i%2 != 0 && mirror_copies) {
+                r *= Geom::Rotate(Geom::Angle(half_dir)).inverse();
+                r *= Geom::Scale(1, -1);
+                r *= Geom::Rotate(Geom::Angle(half_dir));
             }
-        } else {
-            for (size_t i = 1; i < num_copies; ++i) {
-                Geom::Rotate rot(-(Geom::rad_from_deg(rotation_angle * i)));
-                Geom::Affine t = m * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)) * Geom::Translate(origin);
-                t *= sp_lpe_item->transform;
-                toItem(t, i - 1, reset);
+            Geom::Rotate rot(-(Geom::rad_from_deg(rotation_angle * i)));
+            Geom::Affine t = m * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)) * Geom::Translate(origin);
+            if( i%2 != 0 && mirror_copies) {
+                t = m * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)).inverse() * Geom::Translate(origin);
             }
+            t *= sp_lpe_item->transform;
+            toItem(t, i-1, reset);
         }
         reset = false;
     } else {
@@ -302,15 +300,6 @@ Gtk::Widget * LPECopyRotate::newWidget()
     vbox->set_border_width(5);
     vbox->set_homogeneous(false);
     vbox->set_spacing(2);
-    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
-    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
-    vbox_expander->set_border_width(0);
-    vbox_expander->set_spacing(2);
-    Gtk::Button * reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset styles"))));
-    reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPECopyRotate::resetStyles));
-    reset_button->set_size_request(140,30);
-    vbox->pack_start(*hbox, true,true,2);
-    hbox->pack_start(*reset_button, false, false,2);
     std::vector<Parameter *>::iterator it = param_vector.begin();
     while (it != param_vector.end()) {
         if ((*it)->widget_is_visible) {
@@ -332,6 +321,12 @@ Gtk::Widget * LPECopyRotate::newWidget()
 
         ++it;
     }
+    Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0));
+    Gtk::Button * reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset styles"))));
+    reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPECopyRotate::resetStyles));
+    reset_button->set_size_request(110,20);
+    vbox->pack_start(*hbox, true,true,2);
+    hbox->pack_start(*reset_button, false, false,2);
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -344,7 +339,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, true);
+    origin.param_setValue(A);
     origin.param_update_default(A);
     dist_angle_handle = L2(B - A);
     dir = unit_vector(B - A);
@@ -366,13 +361,14 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     using namespace Geom;
     original_bbox(lpeitem);
-    if (copies_to_360) {
+    if (copies_to_360 && num_copies > 2) {
         rotation_angle.param_set_value(360.0/(double)num_copies);
     }
-    if (fuse_paths && rotation_angle * num_copies > 360.1 && rotation_angle > 0) {
+
+    if ((method == RM_KALEIDOSCOPE || method == RM_FUSE) && rotation_angle * num_copies > 360.1 && rotation_angle > 0) {
         num_copies.param_set_value(floor(360/rotation_angle));
     }
-    if (fuse_paths && copies_to_360) {
+    if ((method == RM_KALEIDOSCOPE || method == RM_FUSE)  && mirror_copies && copies_to_360) {
         num_copies.param_set_increments(2.0,10.0);
         if ((int)num_copies%2 !=0) {
             num_copies.param_set_value(num_copies+1);
@@ -391,7 +387,7 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
     // 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) { 
+    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);
@@ -405,11 +401,11 @@ LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
     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);
+    if (!near) {
+        starting_point.param_setValue(start_pos);
     }
     previous_start_point = (Geom::Point)starting_point;
-    if ( fuse_paths || copies_to_360 ) {
+    if ( method == RM_FUSE || copies_to_360 ) {
         rot_pos = origin;
     }
 }
@@ -486,19 +482,21 @@ LPECopyRotate::setFusion(Geom::PathVector &path_on, Geom::Path divider, double s
         }
         Geom::PathVector tmp_path_helper;
         Geom::Path append_path = original;
-
+        Geom::Point previous = original.finalPoint();
         for (int i = 0; i < num_copies; ++i) {
             Geom::Rotate rot(-Geom::rad_from_deg(rotation_angle * (i)));
             Geom::Affine m = pre * rot * Geom::Translate(origin);
-            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::Line ls(A,B);
-                m = Geom::reflection (ls.vector(), A);
+            if (i%2 != 0 && mirror_copies) {
+                Geom::Point point_a = (Geom::Point)origin;
+                Geom::Point point_b = origin + dir * Geom::Rotate(-Geom::rad_from_deg((rotation_angle*i)+starting_angle)) * size_divider;
+                Geom::Line ls(point_a, point_b);
+                m = Geom::reflection (ls.vector(), point_a);
+                append_path *= m;
             } else {
                 append_path = original;
+                append_path *= m;
             }
-            append_path *= m;
+            previous = append_path.finalPoint();
             if (tmp_path_helper.size() > 0) {
                 if (Geom::are_near(tmp_path_helper[tmp_path_helper.size()-1].finalPoint(), append_path.finalPoint())) {
                     Geom::Path tmp_append = append_path.reversed();
@@ -588,118 +586,83 @@ Geom::PathVector
 LPECopyRotate::doEffect_path (Geom::PathVector const & path_in)
 {
     Geom::PathVector path_out;
-    if (split_items && (fuse_paths || join_paths)) {
+    double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
+    Geom::OptRect bbox = sp_lpe_item->geometricBounds();
+    size_divider = Geom::distance(origin,bbox) + (diagonal * 6);
+    Geom::Point line_start  = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(starting_angle))) * size_divider;
+    Geom::Point line_end = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(rotation_angle + starting_angle))) * size_divider;
+    divider = Geom::Path(line_start);
+    divider.appendNew<Geom::LineSegment>((Geom::Point)origin);
+    divider.appendNew<Geom::LineSegment>(line_end);
+    divider.close();
+    half_dir = unit_vector(Geom::middle_point(line_start,line_end) - (Geom::Point)origin);
+    if (method == RM_KALEIDOSCOPE || method == RM_FUSE) {
+        if (method != RM_KALEIDOSCOPE) {
+            path_out = doEffect_path_post(path_in);
+        } else {
+            path_out = pathv_to_linear_and_cubic_beziers(path_in);
+        }
         if (num_copies == 0) {
             return path_out;
         }
-        path_out = pathv_to_linear_and_cubic_beziers(path_in);
-        double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
-        Geom::OptRect bbox = sp_lpe_item->geometricBounds();
-        double size_divider = Geom::distance(origin,bbox) + (diagonal * 2);
-        Geom::Point line_start  = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(starting_angle))) * size_divider;
-        Geom::Point line_end = origin + dir * Geom::Rotate(-(Geom::rad_from_deg(rotation_angle + starting_angle))) * size_divider;
-        Geom::Path divider = Geom::Path(line_start);
-        divider.appendNew<Geom::LineSegment>((Geom::Point)origin);
-        divider.appendNew<Geom::LineSegment>(line_end);
-        divider.close();
         Geom::PathVector triangle;
         triangle.push_back(divider);
         Geom::PathIntersectionGraph *pig = new Geom::PathIntersectionGraph(triangle, path_out);
-        if (pig && ! path_out.empty() && !triangle.empty()) {
-            //TODO: Here can produce a crash because some knows problems in new boolops code
+        if (pig && !path_out.empty() && !triangle.empty()) {
             path_out = pig->getIntersection();
         }
-        Geom::Affine r = Geom::identity();
-        Geom::Point dir = unit_vector(Geom::middle_point(line_start,line_end) - (Geom::Point)origin);
-        Geom::Point gap = dir * split_gap;
-        path_out *= Geom::Translate(gap);
-    } else {
-        // default behavior
-        for (unsigned int i=0; i < path_in.size(); i++) {
-            Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2_in = path_in[i].toPwSb();
-            Geom::Piecewise<Geom::D2<Geom::SBasis> > pwd2_out = doEffect_pwd2(pwd2_in);
-            Geom::PathVector path = Geom::path_from_piecewise( pwd2_out, LPE_CONVERSION_TOLERANCE);
-            // add the output path vector to the already accumulated vector:
-            for (unsigned int j=0; j < path.size(); j++) {
-                path_out.push_back(path[j]);
-            }
+        path_out *= Geom::Translate(half_dir * gap);
+        if ( !split_items ) {
+            path_out *= Geom::Translate(half_dir * gap).inverse();
+            path_out = doEffect_path_post(path_out);
         }
+    } else {
+        path_out = doEffect_path_post(path_in);
     }
     return pathv_to_linear_and_cubic_beziers(path_out);
 }
 
-Geom::Piecewise<Geom::D2<Geom::SBasis> >
-LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
+Geom::PathVector
+LPECopyRotate::doEffect_path_post (Geom::PathVector const & path_in)
 {
-    using namespace Geom;
-
-    if ((num_copies == 1 && !fuse_paths) || split_items) {
-        return pwd2_in;
+    if ((split_items || num_copies == 1) && method != RM_FUSE && method != RM_KALEIDOSCOPE) {
+        return path_in;
     }
 
-    double diagonal = Geom::distance(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
-    Geom::Rect bbox(Geom::Point(boundingbox_X.min(),boundingbox_Y.min()),Geom::Point(boundingbox_X.max(),boundingbox_Y.max()));
-    double size_divider = Geom::distance(origin,bbox) + (diagonal * 2);
-    Geom::Point line_start  = origin + dir * Rotate(-rad_from_deg(starting_angle)) * size_divider;
-    Geom::Point line_end = origin + dir * Rotate(-rad_from_deg(rotation_angle + starting_angle)) * size_divider;
-    //Note:: beter way to do this
-    //Whith AppendNew have problems whith the crossing order
-    Geom::Path divider = Geom::Path(line_start);
-    divider.appendNew<Geom::LineSegment>((Geom::Point)origin);
-    divider.appendNew<Geom::LineSegment>(line_end);
-    Piecewise<D2<SBasis> > output;
-    Affine pre = Translate(-origin) * Rotate(-rad_from_deg(starting_angle));
-    PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(path_from_piecewise(remove_short_cuts(pwd2_in, 0.1), 0.001));
-    if (fuse_paths) {
-        Geom::PathVector path_out;
-        Geom::PathVector tmp_path;
-        for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
-            if (path_it->empty()) {
-                continue;
-            }
-            bool end_open = false;
-            if (path_it->closed()) {
-                const Geom::Curve &closingline = path_it->back_closed();
-                if (!are_near(closingline.initialPoint(), closingline.finalPoint())) {
-                    end_open = true;
-                }
-            }
-            Geom::Path original = (Geom::Path)(*path_it);
-            if (end_open && path_it->closed()) {
-                original.close(false);
-                original.appendNew<Geom::LineSegment>( original.initialPoint() );
-                original.close(true);
-            }
-            tmp_path.push_back(original);
-            setFusion(tmp_path, divider, size_divider);
-            path_out.insert(path_out.end(), tmp_path.begin(), tmp_path.end());
-            tmp_path.clear();
+    Geom::Affine pre = Geom::Translate(-origin) * Geom::Rotate(-Geom::rad_from_deg(starting_angle));
+    Geom::PathVector original_pathv = pathv_to_linear_and_cubic_beziers(path_in);
+    Geom::PathVector output_pv;
+    Geom::PathVector output;
+    for (int i = 0; i < num_copies; ++i) {
+        Geom::Rotate rot(-Geom::rad_from_deg(rotation_angle * i));
+        Geom::Affine r = Geom::identity();
+        if( i%2 != 0 && mirror_copies) {
+            r *= Geom::Rotate(Geom::Angle(half_dir)).inverse();
+            r *= Geom::Scale(1, -1);
+            r *= Geom::Rotate(Geom::Angle(half_dir));
         }
-        if (path_out.size()>0) {
-            output = paths_to_pw(path_out);
+        Geom::Affine t = pre * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)) * Geom::Translate(origin);
+        if(mirror_copies && i%2 != 0) {
+            t = pre * r * rot * Geom::Rotate(Geom::rad_from_deg(starting_angle)).inverse() * Geom::Translate(origin);
         }
-    } else {
-        Geom::PathVector output_pv;
-        for (int i = 0; i < num_copies; ++i) {
-            Rotate rot(-rad_from_deg(rotation_angle * i));
-            Affine t = pre * rot * Translate(origin);
-            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;
-                    }
+        if (method == RM_FUSE || method == RM_KALEIDOSCOPE) {
+            Geom::PathVector join_pv = original_pathv * t;
+            join_pv *= Geom::Translate(half_dir * rot * gap);
+            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);
             }
+        } else {
+            output_pv = path_in * t;
+            output.insert(output.end(), output_pv.begin(), output_pv.end());
         }
-        if (join_paths) {
-            output = paths_to_pw(output_pv);
-        }
+    }
+    if (method == RM_FUSE || method == RM_KALEIDOSCOPE) {
+        output = output_pv;
     }
     return output;
 }
diff --git a/src/live_effects/lpe-copy_rotate.h b/src/live_effects/lpe-copy_rotate.h
index dbec2e1c3..542a4e36e 100644
--- a/src/live_effects/lpe-copy_rotate.h
+++ b/src/live_effects/lpe-copy_rotate.h
@@ -15,6 +15,7 @@
  */
 
 #include "live_effects/effect.h"
+#include "live_effects/parameter/enum.h"
 #include "live_effects/parameter/parameter.h"
 #include "live_effects/parameter/text.h"
 #include "live_effects/parameter/point.h"
@@ -23,13 +24,20 @@
 namespace Inkscape {
 namespace LivePathEffect {
 
+enum RotateMethod {
+    RM_NORMAL,
+    RM_KALEIDOSCOPE,
+    RM_FUSE,
+    RM_END
+};
+
 class LPECopyRotate : public Effect, GroupBBoxEffect {
 public:
     LPECopyRotate(LivePathEffectObject *lpeobject);
     virtual ~LPECopyRotate();
     virtual void doOnApply (SPLPEItem const* lpeitem);
     virtual Geom::PathVector doEffect_path (Geom::PathVector const & path_in);
-    virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
+    Geom::PathVector doEffect_path_post (Geom::PathVector const & path_in);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
     virtual void doAfterEffect (SPLPEItem const* lpeitem);
     virtual void setFusion(Geom::PathVector &path_in, Geom::Path divider, double sizeDivider);
@@ -51,18 +59,21 @@ private:
     ScalarParam starting_angle;
     ScalarParam rotation_angle;
     ScalarParam num_copies;
-    ScalarParam split_gap;
+    ScalarParam gap;
     BoolParam copies_to_360;
-    BoolParam fuse_paths;
-    BoolParam join_paths;
+    EnumParam<RotateMethod> method;
+    BoolParam mirror_copies;
     BoolParam split_items;
     Geom::Point A;
     Geom::Point B;
     Geom::Point dir;
+    Geom::Point half_dir;
     Geom::Point start_pos;
     Geom::Point rot_pos;
     Geom::Point previous_start_point;
     double dist_angle_handle;
+    double size_divider;
+    Geom::Path divider;
     double previous_num_copies;
     bool reset;
     SPObject * container;
diff --git a/src/live_effects/lpe-curvestitch.cpp b/src/live_effects/lpe-curvestitch.cpp
index f2fc00aeb..f8d2e56ca 100644
--- a/src/live_effects/lpe-curvestitch.cpp
+++ b/src/live_effects/lpe-curvestitch.cpp
@@ -40,14 +40,14 @@ LPECurveStitch::LPECurveStitch(LivePathEffectObject *lpeobject) :
     prop_scale(_("Scale _width:"), _("Scale the width of the stitch path"), "prop_scale", &wr, this, 1),
     scale_y_rel(_("Scale _width relative to length"), _("Scale the width of the stitch path relative to its length"), "scale_y_rel", &wr, this, false)
 {
-    registerParameter( dynamic_cast<Parameter *>(&nrofpaths) );
-    registerParameter( dynamic_cast<Parameter *>(&startpoint_edge_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&startpoint_spacing_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&endpoint_edge_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&endpoint_spacing_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&strokepath) );
-    registerParameter( dynamic_cast<Parameter *>(&prop_scale) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_y_rel) );
+    registerParameter(&nrofpaths);
+    registerParameter(&startpoint_edge_variation);
+    registerParameter(&startpoint_spacing_variation);
+    registerParameter(&endpoint_edge_variation);
+    registerParameter(&endpoint_spacing_variation);
+    registerParameter(&strokepath );
+    registerParameter(&prop_scale);
+    registerParameter(&scale_y_rel);
 
     nrofpaths.param_make_integer();
     nrofpaths.param_set_range(2, Geom::infinity());
diff --git a/src/live_effects/lpe-dynastroke.cpp b/src/live_effects/lpe-dynastroke.cpp
index 50bbe6451..33e754a8a 100644
--- a/src/live_effects/lpe-dynastroke.cpp
+++ b/src/live_effects/lpe-dynastroke.cpp
@@ -55,17 +55,17 @@ LPEDynastroke::LPEDynastroke(LivePathEffectObject *lpeobject) :
     capping(_("Capping:"), _("left capping"), "capping", &wr, this, "M 100,5 C 50,5 0,0 0,0 0,0 50,-5 100,-5")
 {
 
-    registerParameter( dynamic_cast<Parameter *>(& method) );
-    registerParameter( dynamic_cast<Parameter *>(& width) );
-    registerParameter( dynamic_cast<Parameter *>(& roundness) );
-    registerParameter( dynamic_cast<Parameter *>(& angle) );
-    //registerParameter( dynamic_cast<Parameter *>(& modulo_pi) );
-    registerParameter( dynamic_cast<Parameter *>(& start_cap) );
-    registerParameter( dynamic_cast<Parameter *>(& growfor) );
-    registerParameter( dynamic_cast<Parameter *>(& end_cap) );
-    registerParameter( dynamic_cast<Parameter *>(& fadefor) );
-    registerParameter( dynamic_cast<Parameter *>(& round_ends) );
-    registerParameter( dynamic_cast<Parameter *>(& capping) );
+    registerParameter(&method);
+    registerParameter(&width);
+    registerParameter(&roundness);
+    registerParameter(&angle);
+    //registerParameter(&modulo_pi) );
+    registerParameter(&start_cap);
+    registerParameter(&growfor);
+    registerParameter(&end_cap);
+    registerParameter(&fadefor);
+    registerParameter(&round_ends);
+    registerParameter(&capping);
 
     width.param_set_range(0, Geom::infinity());
     roundness.param_set_range(0.01, 1);
diff --git a/src/live_effects/lpe-envelope.cpp b/src/live_effects/lpe-envelope.cpp
index 61a696435..8528ab14d 100644
--- a/src/live_effects/lpe-envelope.cpp
+++ b/src/live_effects/lpe-envelope.cpp
@@ -23,12 +23,12 @@ LPEEnvelope::LPEEnvelope(LivePathEffectObject *lpeobject) :
     xx(_("_Enable left & right paths"), _("Enable the left and right deformation paths"), "xx", &wr, this, true),
     yy(_("_Enable top & bottom paths"), _("Enable the top and bottom deformation paths"), "yy", &wr, this, true)
 {
-    registerParameter( dynamic_cast<Parameter *>(&yy) );
-    registerParameter( dynamic_cast<Parameter *>(&xx) );
-    registerParameter( dynamic_cast<Parameter *>(&bend_path1) );
-    registerParameter( dynamic_cast<Parameter *>(&bend_path2) );
-    registerParameter( dynamic_cast<Parameter *>(&bend_path3) );
-    registerParameter( dynamic_cast<Parameter *>(&bend_path4) );
+    registerParameter(&yy);
+    registerParameter(&xx);
+    registerParameter(&bend_path1);
+    registerParameter(&bend_path2);
+    registerParameter(&bend_path3);
+    registerParameter(&bend_path4);
     concatenate_before_pwd2 = true;
     apply_to_clippath_and_mask = true;
 }
diff --git a/src/live_effects/lpe-extrude.cpp b/src/live_effects/lpe-extrude.cpp
index daa30d45a..4a3ad7508 100644
--- a/src/live_effects/lpe-extrude.cpp
+++ b/src/live_effects/lpe-extrude.cpp
@@ -27,7 +27,7 @@ LPEExtrude::LPEExtrude(LivePathEffectObject *lpeobject) :
     show_orig_path = true;
     concatenate_before_pwd2 = false;
 
-    registerParameter( dynamic_cast<Parameter *>(&extrude_vector) );
+    registerParameter(&extrude_vector);
 }
 
 LPEExtrude::~LPEExtrude()
diff --git a/src/live_effects/lpe-fill-between-many.cpp b/src/live_effects/lpe-fill-between-many.cpp
index 2e1fe0dc1..40fa91c68 100644
--- a/src/live_effects/lpe-fill-between-many.cpp
+++ b/src/live_effects/lpe-fill-between-many.cpp
@@ -25,11 +25,11 @@ LPEFillBetweenMany::LPEFillBetweenMany(LivePathEffectObject *lpeobject) :
     join(_("Join subpaths"), _("Join subpaths"), "join", &wr, this, true),
     close(_("Close"), _("Close path"), "close", &wr, this, true)
 {
-    registerParameter( dynamic_cast<Parameter *>(&linked_paths) );
-    registerParameter( dynamic_cast<Parameter *>(&fuse) );
-    registerParameter( dynamic_cast<Parameter *>(&allow_transforms) );
-    registerParameter( dynamic_cast<Parameter *>(&join) );
-    registerParameter( dynamic_cast<Parameter *>(&close) );
+    registerParameter(&linked_paths);
+    registerParameter(&fuse);
+    registerParameter(&allow_transforms);
+    registerParameter(&join);
+    registerParameter(&close);
     transformmultiply = false;
 }
 
diff --git a/src/live_effects/lpe-fill-between-strokes.cpp b/src/live_effects/lpe-fill-between-strokes.cpp
index 43fef4288..f8d86ae99 100644
--- a/src/live_effects/lpe-fill-between-strokes.cpp
+++ b/src/live_effects/lpe-fill-between-strokes.cpp
@@ -25,13 +25,13 @@ LPEFillBetweenStrokes::LPEFillBetweenStrokes(LivePathEffectObject *lpeobject) :
     join(_("Join subpaths"), _("Join subpaths"), "join", &wr, this, true),
     close(_("Close"), _("Close path"), "close", &wr, this, true)
 {
-    registerParameter( dynamic_cast<Parameter *>(&linked_path) );
-    registerParameter( dynamic_cast<Parameter *>(&second_path) );
-    registerParameter( dynamic_cast<Parameter *>(&reverse_second) );
-    registerParameter( dynamic_cast<Parameter *>(&fuse) );
-    registerParameter( dynamic_cast<Parameter *>(&allow_transforms) );
-    registerParameter( dynamic_cast<Parameter *>(&join) );
-    registerParameter( dynamic_cast<Parameter *>(&close) );
+    registerParameter(&linked_path);
+    registerParameter(&second_path);
+    registerParameter(&reverse_second);
+    registerParameter(&fuse);
+    registerParameter(&allow_transforms);
+    registerParameter(&join);
+    registerParameter(&close);
     transformmultiply = false;
 }
 
diff --git a/src/live_effects/lpe-fillet-chamfer.cpp b/src/live_effects/lpe-fillet-chamfer.cpp
index 410d6f0fc..b9e96cb72 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -305,6 +305,8 @@ void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
         } else {
             satellites_param.setHelperSize(helper_size);
         }
+        std::vector<size_t> selected_nodes_index;
+        size_t index = 0;
         for (size_t i = 0; i < satellites.size(); ++i) {
             for (size_t j = 0; j < satellites[i].size(); ++j) {
                 if (satellites[i][j].is_time != flexible) {
@@ -326,6 +328,11 @@ void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
                     satellites[i][j].has_mirror = mirror_knots;
                 }
                 satellites[i][j].hidden = hide_knots;
+                Geom::Curve const &curve_in = pathv[i][j];
+                if (only_selected && isNodePointSelected(curve_in.initialPoint()) ){
+                    selected_nodes_index.push_back(index);
+                }
+                index ++;
             }
         }
         if (!_pathvector_satellites) {
@@ -334,7 +341,6 @@ void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
         _pathvector_satellites->setPathVector(pathv);
         _pathvector_satellites->setSatellites(satellites);
         if (only_selected) {
-            setSelectedNodeIndex(pathv);
             _pathvector_satellites->setSelected(selected_nodes_index);
         }
         satellites_param.setPathVectorSatellites(_pathvector_satellites);
diff --git a/src/live_effects/lpe-interpolate.cpp b/src/live_effects/lpe-interpolate.cpp
index e95dc5f38..db3faa307 100644
--- a/src/live_effects/lpe-interpolate.cpp
+++ b/src/live_effects/lpe-interpolate.cpp
@@ -30,9 +30,9 @@ LPEInterpolate::LPEInterpolate(LivePathEffectObject *lpeobject) :
 {
     show_orig_path = true;
 
-    registerParameter( dynamic_cast<Parameter *>(&trajectory_path) );
-    registerParameter( dynamic_cast<Parameter *>(&equidistant_spacing) );
-    registerParameter( dynamic_cast<Parameter *>(&number_of_steps) );
+    registerParameter(&trajectory_path);
+    registerParameter(&equidistant_spacing);
+    registerParameter(&number_of_steps);
 
     number_of_steps.param_make_integer();
     number_of_steps.param_set_range(2, Geom::infinity());
diff --git a/src/live_effects/lpe-knot.cpp b/src/live_effects/lpe-knot.cpp
index 2defecb77..261612fdb 100644
--- a/src/live_effects/lpe-knot.cpp
+++ b/src/live_effects/lpe-knot.cpp
@@ -356,12 +356,12 @@ LPEKnot::LPEKnot(LivePathEffectObject *lpeobject) :
     switcher(0.,0.)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&interruption_width) );
-    registerParameter( dynamic_cast<Parameter *>(&prop_to_stroke_width) );
-    registerParameter( dynamic_cast<Parameter *>(&add_stroke_width) );
-    registerParameter( dynamic_cast<Parameter *>(&add_other_stroke_width) );
-    registerParameter( dynamic_cast<Parameter *>(&switcher_size) );
-    registerParameter( dynamic_cast<Parameter *>(&crossing_points_vector) );
+    registerParameter(&interruption_width);
+    registerParameter(&prop_to_stroke_width);
+    registerParameter(&add_stroke_width);
+    registerParameter(&add_other_stroke_width);
+    registerParameter(&switcher_size);
+    registerParameter(&crossing_points_vector);
 
     _provides_knotholder_entities = true;
 }
diff --git a/src/live_effects/lpe-lattice.cpp b/src/live_effects/lpe-lattice.cpp
index acffed000..124a7a9c6 100644
--- a/src/live_effects/lpe-lattice.cpp
+++ b/src/live_effects/lpe-lattice.cpp
@@ -50,22 +50,22 @@ LPELattice::LPELattice(LivePathEffectObject *lpeobject) :
     
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&grid_point0) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point1) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point2) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point3) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point4) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point5) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point6) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point7) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point8) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point9) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point10) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point11) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point12) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point13) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point14) );
-    registerParameter( dynamic_cast<Parameter *>(&grid_point15) );
+    registerParameter(&grid_point0);
+    registerParameter(&grid_point1);
+    registerParameter(&grid_point2);
+    registerParameter(&grid_point3);
+    registerParameter(&grid_point4);
+    registerParameter(&grid_point5);
+    registerParameter(&grid_point6);
+    registerParameter(&grid_point7);
+    registerParameter(&grid_point8);
+    registerParameter(&grid_point9);
+    registerParameter(&grid_point10);
+    registerParameter(&grid_point11);
+    registerParameter(&grid_point12);
+    registerParameter(&grid_point13);
+    registerParameter(&grid_point14);
+    registerParameter(&grid_point15);
 
     apply_to_clippath_and_mask = true;
 }
diff --git a/src/live_effects/lpe-line_segment.cpp b/src/live_effects/lpe-line_segment.cpp
index cc024fb92..fd23da804 100644
--- a/src/live_effects/lpe-line_segment.cpp
+++ b/src/live_effects/lpe-line_segment.cpp
@@ -32,7 +32,7 @@ LPELineSegment::LPELineSegment(LivePathEffectObject *lpeobject) :
     end_type(_("End type:"), _("Determines on which side the line or line segment is infinite."), "end_type", EndTypeConverter, &wr, this, END_OPEN_BOTH)
 {
     /* register all your parameters here, so Inkscape knows which parameters this effect has: */
-    registerParameter( dynamic_cast<Parameter *>(&end_type) );
+    registerParameter(&end_type);
 }
 
 LPELineSegment::~LPELineSegment()
diff --git a/src/live_effects/lpe-measure-line.cpp b/src/live_effects/lpe-measure-line.cpp
index 86d72615c..892744462 100644
--- a/src/live_effects/lpe-measure-line.cpp
+++ b/src/live_effects/lpe-measure-line.cpp
@@ -49,32 +49,33 @@ static const Util::EnumDataConverter<OrientationMethod> OMConverter(OrientationM
 
 LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
-    unit(_("Unit*"), _("Unit"), "unit", &wr, this, "px"),
-    fontbutton(_("Font*"), _("Font Selector"), "fontbutton", &wr, this),
+    unit(_("Unit"), _("Unit"), "unit", &wr, this, "px"),
+    fontbutton(_("Font"), _("Font Selector"), "fontbutton", &wr, this),
     orientation(_("Orientation"), _("Orientation method"), "orientation", OMConverter, &wr, this, OM_PARALLEL, false),
     curve_linked(_("Curve on origin"), _("Curve on origin, set 0 to start/end"), "curve_linked", &wr, this, 1),
-    precision(_("Precision*"), _("Precision"), "precision", &wr, this, 2),
-    position(_("Position*"), _("Position"), "position", &wr, this, 5),
-    text_top_bottom(_("Text top/bottom*"), _("Text top/bottom"), "text_top_bottom", &wr, this, 0),
-    text_right_left(_("Text right/left*"), _("Text right/left"), "text_right_left", &wr, this, 0),
-    helpline_distance(_("Helpline distance*"), _("Helpline distance"), "helpline_distance", &wr, this, 0.0),
-    helpline_overlap(_("Helpline overlap*"), _("Helpline overlap"), "helpline_overlap", &wr, this, 2.0),
-    scale(_("Scale*"), _("Scaling factor"), "scale", &wr, this, 1.0),
-    format(_("Format*"), _("Format the number ex:{measure} {unit}, return to save"), "format", &wr, this,"{measure}{unit}"),
+    precision(_("Precision"), _("Precision"), "precision", &wr, this, 2),
+    position(_("Position"), _("Position"), "position", &wr, this, 5),
+    text_top_bottom(_("Text top/bottom"), _("Text top/bottom"), "text_top_bottom", &wr, this, 0),
+    text_right_left(_("Text right/left"), _("Text right/left"), "text_right_left", &wr, this, 0),
+    helpline_distance(_("Helpline distance"), _("Helpline distance"), "helpline_distance", &wr, this, 0.0),
+    helpline_overlap(_("Helpline overlap"), _("Helpline overlap"), "helpline_overlap", &wr, this, 2.0),
+    scale(_("Scale"), _("Scaling factor"), "scale", &wr, this, 1.0),
+    format(_("Format"), _("Format the number ex:{measure} {unit}, return to save"), "format", &wr, this,"{measure}{unit}"),
     id_origin("id_origin", "id_origin", "id_origin", &wr, this,""),
     arrows_outside(_("Arrows outside"), _("Arrows outside"), "arrows_outside", &wr, this, false),
-    flip_side(_("Flip side*"), _("Flip side"), "flip_side", &wr, this, false),
-    scale_sensitive(_("Scale sensitive*"), _("Costrained scale sensitive to transformed containers"), "scale_sensitive", &wr, this, true),
-    local_locale(_("Local Number Format*"), _("Local number format"), "local_locale", &wr, this, true),
-    line_group_05(_("Line Group 0.5*"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
-    rotate_anotation(_("Rotate Anotation*"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true),
-    hide_back(_("Hide if label over*"), _("Hide DIN line if label over"), "hide_back", &wr, this, true),
-    dimline_format(_("CSS DIN line*"), _("Override CSS to DIN line, return to save, empty to reset to DIM"), "dimline_format", &wr, this,""),
-    helperlines_format(_("CSS helpers*"), _("Override CSS to helper lines, return to save, empty to reset to DIM"), "helperlines_format", &wr, this,""),
-    anotation_format(_("CSS anotation*"), _("Override CSS to anotation text, return to save, empty to reset to DIM"), "anotation_format", &wr, this,""),
-    arrows_format(_("CSS arrows*"), _("Override CSS to arrows, return to save, empty to reset DIM"), "arrows_format", &wr, this,""),
+    flip_side(_("Flip side"), _("Flip side"), "flip_side", &wr, this, false),
+    scale_sensitive(_("Scale sensitive"), _("Costrained scale sensitive to transformed containers"), "scale_sensitive", &wr, this, true),
+    local_locale(_("Local Number Format"), _("Local number format"), "local_locale", &wr, this, true),
+    line_group_05(_("Line Group 0.5"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
+    rotate_anotation(_("Rotate Anotation"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true),
+    hide_back(_("Hide if label over"), _("Hide DIN line if label over"), "hide_back", &wr, this, true),
+    dimline_format(_("CSS DIN line"), _("Override CSS to DIN line, return to save, empty to reset to DIM"), "dimline_format", &wr, this,""),
+    helperlines_format(_("CSS helpers"), _("Override CSS to helper lines, return to save, empty to reset to DIM"), "helperlines_format", &wr, this,""),
+    anotation_format(_("CSS anotation"), _("Override CSS to anotation text, return to save, empty to reset to DIM"), "anotation_format", &wr, this,""),
+    arrows_format(_("CSS arrows"), _("Override CSS to arrows, return to save, empty to reset DIM"), "arrows_format", &wr, this,""),
     expanded(false)
 {
+    //set to true the parameters you want to be changed his default values
     registerParameter(&unit);
     registerParameter(&fontbutton);
     registerParameter(&orientation);
@@ -99,39 +100,16 @@ LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
     registerParameter(&anotation_format);
     registerParameter(&arrows_format);
     registerParameter(&id_origin);
+
     id_origin.param_hide_canvas_text();
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    Glib::ustring fontbutton_value = prefs->getString("/live_effects/measure-line/fontbutton");
-    if(fontbutton_value.empty()){
-        fontbutton_value = "Sans 10";
-    }
-    fontbutton.param_update_default(fontbutton_value);
-    scale.param_update_default(prefs->getDouble("/live_effects/measure-line/scale", 1.0));
-    precision.param_update_default(prefs->getInt("/live_effects/measure-line/precision", 2));
-    position.param_update_default(prefs->getDouble("/live_effects/measure-line/position", 10.0));
-    text_top_bottom.param_update_default(prefs->getDouble("/live_effects/measure-line/text_top_bottom", 5.0));
-    helpline_distance.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_distance", 0.0));
-    helpline_overlap.param_update_default(prefs->getDouble("/live_effects/measure-line/helpline_overlap", 0.0));
-    Glib::ustring unit_value = prefs->getString("/live_effects/measure-line/unit");
-    if(unit_value.empty()){
-        unit_value = "px";
-    }
-    unit.param_update_default(unit_value);
+
     Glib::ustring format_value = prefs->getString("/live_effects/measure-line/format");
     if(format_value.empty()){
         format_value = "{measure}{unit}";
     }
-    format.param_update_default(format_value);
-    dimline_format.param_update_default(prefs->getString("/live_effects/measure-line/dimline_format"));
-    helperlines_format.param_update_default(prefs->getString("/live_effects/measure-line/helperlines_format"));
-    anotation_format.param_update_default(prefs->getString("/live_effects/measure-line/anotation_format"));
-    arrows_format.param_update_default(prefs->getString("/live_effects/measure-line/arrows_format"));
-    flip_side.param_update_default(prefs->getBool("/live_effects/measure-line/flip_side"));
-    scale_sensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_sensitive"));
-    local_locale.param_update_default(prefs->getBool("/live_effects/measure-line/local_locale"));
-    line_group_05.param_update_default(prefs->getBool("/live_effects/measure-line/line_group_05"));
-    rotate_anotation.param_update_default(prefs->getBool("/live_effects/measure-line/rotate_anotation"));
-    hide_back.param_update_default(prefs->getBool("/live_effects/measure-line/hide_back"));
+    format.param_update_default(format_value.c_str());
+
     format.param_hide_canvas_text();
     dimline_format.param_hide_canvas_text();
     helperlines_format.param_hide_canvas_text();
@@ -375,7 +353,7 @@ LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angl
     items.push_back(id);
     Geom::OptRect bounds = SP_ITEM(elemref)->bounds(SPItem::GEOMETRIC_BBOX);
     if (bounds) {
-        anotation_width = bounds->width() * 1.4;
+        anotation_width = bounds->width() * 1.15;
     }
 }
 
@@ -405,8 +383,14 @@ LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, const char * id, b
             k = (Geom::distance(start,end)/2.0) - arrow_gap - (anotation_width/2.0);
         }
         if (Geom::distance(start,end) < anotation_width){
-            return;
+            if ((elemref = document->getObjectById(id))) {
+                if (remove) {
+                    elemref->deleteObject();
+                }
+                return;
+            }
         }
+        //k = std::max(k , arrow_gap -1);
         Geom::Ray ray(end, start);
         Geom::Coord angle = ray.angle();
         line_path.start(start);
@@ -527,7 +511,6 @@ LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
         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()) {
@@ -622,6 +605,9 @@ LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
         }
         bool overflow = false;
         const char * downline = g_strdup(Glib::ustring("downline-").append(this->getRepr()->attribute("id")).c_str());
+        //delete residual lines if exist
+        createLine(Geom::Point(),Geom::Point(), downline, true, overflow, true, false);
+        //Create it 
         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);
@@ -645,9 +631,6 @@ LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
             }
             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());
@@ -708,44 +691,41 @@ Gtk::Widget *LPEMeasureLine::newWidget()
     vbox->set_spacing(2);
 
     std::vector<Parameter *>::iterator it = param_vector.begin();
-    Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
     Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
     vbox_expander->set_border_width(0);
     vbox_expander->set_spacing(2);
     while (it != param_vector.end()) {
         if ((*it)->widget_is_visible) {
             Parameter *param = *it;
-            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
-            Glib::ustring *tip = param->param_getTooltip();
-            if (widg) {
-                if (param->param_key != "dimline_format" &&
-                    param->param_key != "helperlines_format" &&
-                    param->param_key != "arrows_format" &&
-                    param->param_key != "anotation_format") {
-                    vbox->pack_start(*widg, true, true, 2);
-                } else {
-                    vbox_expander->pack_start(*widg, true, true, 2);
-                }
-                if (tip) {
-                    widg->set_tooltip_text(*tip);
-                } else {
-                    widg->set_tooltip_text("");
-                    widg->set_has_tooltip(false);
+            if (param->param_key != "id_origin") {
+                Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+                Glib::ustring *tip = param->param_getTooltip();
+                if (widg) {
+                    if (param->param_key != "dimline_format" &&
+                        param->param_key != "helperlines_format" &&
+                        param->param_key != "arrows_format" &&
+                        param->param_key != "anotation_format") {
+                        vbox->pack_start(*widg, true, true, 2);
+                    } else {
+                        vbox_expander->pack_start(*widg, true, true, 2);
+                    }
+                    if (tip) {
+                        widg->set_tooltip_text(*tip);
+                    } else {
+                        widg->set_tooltip_text("");
+                        widg->set_has_tooltip(false);
+                    }
                 }
             }
         }
 
         ++it;
     }
-    Gtk::Button *save_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Save '*' as default"))));
-    save_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::saveDefault));
-    button1->pack_start(*save_default, true, true, 2);
     expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show DIM CSS style override"))));
     expander->add(*vbox_expander);
     expander->set_expanded(expanded);
     expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPEMeasureLine::onExpanderChanged) );
     vbox->pack_start(*expander, true, true, 2);
-    vbox->pack_start(*button1, true, true, 2);
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -766,31 +746,6 @@ LPEMeasureLine::doEffect_path(Geom::PathVector const &path_in)
     return path_in;
 }
 
-void
-LPEMeasureLine::saveDefault()
-{
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setString("/live_effects/measure-line/fontbutton", Glib::ustring(fontbutton.param_getSVGValue()));
-    prefs->setDouble("/live_effects/measure-line/scale", scale);
-    prefs->setInt("/live_effects/measure-line/precision", precision);
-    prefs->setDouble("/live_effects/measure-line/position", position);
-    prefs->setDouble("/live_effects/measure-line/text_top_bottom", text_top_bottom);
-    prefs->setDouble("/live_effects/measure-line/helpline_distance", helpline_distance);
-    prefs->setDouble("/live_effects/measure-line/helpline_overlap", helpline_overlap);
-    prefs->setString("/live_effects/measure-line/unit", Glib::ustring(unit.get_abbreviation()));
-    prefs->setString("/live_effects/measure-line/format", Glib::ustring(format.param_getSVGValue()));
-    prefs->setString("/live_effects/measure-line/dimline_format", Glib::ustring(dimline_format.param_getSVGValue()));
-    prefs->setString("/live_effects/measure-line/helperlines_format", Glib::ustring(helperlines_format.param_getSVGValue()));
-    prefs->setString("/live_effects/measure-line/anotation_format", Glib::ustring(anotation_format.param_getSVGValue()));
-    prefs->setString("/live_effects/measure-line/arrows_format", Glib::ustring(arrows_format.param_getSVGValue()));
-    prefs->setBool("/live_effects/measure-line/flip_side", flip_side);
-    prefs->setBool("/live_effects/measure-line/scale_sensitive", scale_sensitive);
-    prefs->setBool("/live_effects/measure-line/local_locale", local_locale);
-    prefs->setBool("/live_effects/measure-line/line_group_05", line_group_05);
-    prefs->setBool("/live_effects/measure-line/rotate_anotation", rotate_anotation);
-    prefs->setBool("/live_effects/measure-line/hide_back", hide_back);
-}
-
 }; //namespace LivePathEffect
 }; /* namespace Inkscape */
 
diff --git a/src/live_effects/lpe-measure-line.h b/src/live_effects/lpe-measure-line.h
index 724c0d924..b42f7cfd5 100644
--- a/src/live_effects/lpe-measure-line.h
+++ b/src/live_effects/lpe-measure-line.h
@@ -49,7 +49,6 @@ public:
     void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove, bool valid);
     void onExpanderChanged();
     void createArrowMarker(const char * mode);
-    void saveDefault();
     virtual Gtk::Widget *newWidget();
 private:
     UnitParam unit;
diff --git a/src/live_effects/lpe-mirror_symmetry.cpp b/src/live_effects/lpe-mirror_symmetry.cpp
index 97015c34d..4e93a2572 100644
--- a/src/live_effects/lpe-mirror_symmetry.cpp
+++ b/src/live_effects/lpe-mirror_symmetry.cpp
@@ -126,61 +126,61 @@ LPEMirrorSymmetry::doBeforeEffect (SPLPEItem const* lpeitem)
         point_b = Geom::Point(center_point[X],boundingbox_Y.max());
     }
     if ((Geom::Point)start_point == (Geom::Point)end_point) {
-        start_point.param_setValue(point_a, true);
-        end_point.param_setValue(point_b, true);
+        start_point.param_setValue(point_a);
+        end_point.param_setValue(point_b);
         previous_center = Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point);
-        center_point.param_setValue(previous_center, true);
+        center_point.param_setValue(previous_center);
         return;
     }
     if ( mode == MT_X || mode == MT_Y ) {
         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);
+            end_point.param_setValue(point_b);
+            start_point.param_setValue(point_a);
         } else {
             if ( mode == MT_X ) {
                 if (!are_near(start_point[X], point_a[X], 0.01)) {
-                    start_point.param_setValue(point_a, true);
+                    start_point.param_setValue(point_a);
                 }
                 if (!are_near(end_point[X], point_b[X], 0.01)) {
-                    end_point.param_setValue(point_b, true);
+                    end_point.param_setValue(point_b);
                 }
             } else {  //MT_Y
                 if (!are_near(start_point[Y], point_a[Y], 0.01)) {
-                    start_point.param_setValue(point_a, true);
+                    start_point.param_setValue(point_a);
                 }
                 if (!are_near(end_point[Y], point_b[Y], 0.01)) {
-                    end_point.param_setValue(point_b, true);
+                    end_point.param_setValue(point_b);
                 }
             }
         }
     } else if ( mode == MT_FREE) {
         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);
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point));
         } else {
             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);
+            start_point.param_setValue(start_point * trans);
+            end_point.param_setValue(end_point * trans);
         }
     } else if ( mode == MT_V){
         SPDocument * document = SP_ACTIVE_DOCUMENT;
         if (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);
+            start_point.param_setValue(sp);
             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);
+            end_point.param_setValue(ep);
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point));
         }
     } else { //horizontal page
         SPDocument * document = SP_ACTIVE_DOCUMENT;
         if (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);
+            start_point.param_setValue(sp);
             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);
+            end_point.param_setValue(ep);
+            center_point.param_setValue(Geom::middle_point((Geom::Point)start_point, (Geom::Point)end_point));
         }
     }
     previous_center = center_point;
@@ -335,7 +335,6 @@ LPEMirrorSymmetry::newWidget()
 
         ++it;
     }
-    this->upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -382,7 +381,7 @@ LPEMirrorSymmetry::doOnApply (SPLPEItem const* lpeitem)
     start_point.param_update_default(point_a);
     end_point.param_setValue(point_b);
     end_point.param_update_default(point_b);
-    center_point.param_setValue(point_c, true);
+    center_point.param_setValue(point_c);
     previous_center = center_point;
     SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
     if (!lpeitem->hasPathEffectOfType(this->effectType(), false) ){ //first applied not ready yet
diff --git a/src/live_effects/lpe-offset.cpp b/src/live_effects/lpe-offset.cpp
index 057f404e0..a5d1d23c8 100644
--- a/src/live_effects/lpe-offset.cpp
+++ b/src/live_effects/lpe-offset.cpp
@@ -27,7 +27,7 @@ LPEOffset::LPEOffset(LivePathEffectObject *lpeobject) :
 {
     show_orig_path = true;
     apply_to_clippath_and_mask = true;
-    registerParameter(dynamic_cast<Parameter *>(&offset_pt));
+    registerParameter(&offset_pt);
 }
 
 LPEOffset::~LPEOffset()
@@ -39,7 +39,7 @@ LPEOffset::doOnApply(SPLPEItem const* lpeitem)
 {
     Geom::Point offset = *(SP_SHAPE(lpeitem)->_curve->first_point());
     offset_pt.param_update_default(offset);
-    offset_pt.param_setValue(offset,true);
+    offset_pt.param_setValue(offset);
 }
 
 static void append_half_circle(Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
diff --git a/src/live_effects/lpe-parallel.cpp b/src/live_effects/lpe-parallel.cpp
index 276749c43..271442c7d 100644
--- a/src/live_effects/lpe-parallel.cpp
+++ b/src/live_effects/lpe-parallel.cpp
@@ -51,9 +51,9 @@ LPEParallel::LPEParallel(LivePathEffectObject *lpeobject) :
     show_orig_path = true;
     _provides_knotholder_entities = true;
 
-    registerParameter(dynamic_cast<Parameter *>(&offset_pt));
-    registerParameter( dynamic_cast<Parameter *>(&length_left) );
-    registerParameter( dynamic_cast<Parameter *>(&length_right) );
+    registerParameter(&offset_pt);
+    registerParameter(&length_left);
+    registerParameter(&length_right);
 }
 
 LPEParallel::~LPEParallel()
diff --git a/src/live_effects/lpe-path_length.cpp b/src/live_effects/lpe-path_length.cpp
index a06dbde98..61818a73b 100644
--- a/src/live_effects/lpe-path_length.cpp
+++ b/src/live_effects/lpe-path_length.cpp
@@ -26,10 +26,10 @@ LPEPathLength::LPEPathLength(LivePathEffectObject *lpeobject) :
     unit(_("Unit:"), _("Unit"), "unit", &wr, this),
     display_unit(_("Display unit"), _("Print unit after path length"), "display_unit", &wr, this, true)
 {
-    registerParameter(dynamic_cast<Parameter *>(&scale));
-    registerParameter(dynamic_cast<Parameter *>(&info_text));
-    registerParameter(dynamic_cast<Parameter *>(&unit));
-    registerParameter(dynamic_cast<Parameter *>(&display_unit));
+    registerParameter(&scale);
+    registerParameter(&info_text);
+    registerParameter(&unit);
+    registerParameter(&display_unit);
 }
 
 LPEPathLength::~LPEPathLength()
diff --git a/src/live_effects/lpe-patternalongpath.cpp b/src/live_effects/lpe-patternalongpath.cpp
index 966e9020e..b026bbc22 100644
--- a/src/live_effects/lpe-patternalongpath.cpp
+++ b/src/live_effects/lpe-patternalongpath.cpp
@@ -85,16 +85,16 @@ LPEPatternAlongPath::LPEPatternAlongPath(LivePathEffectObject *lpeobject) :
     fuse_tolerance(_("_Fuse nearby ends:"), _("Fuse ends closer than this number. 0 means don't fuse."),
         "fuse_tolerance", &wr, this, 0)
 {
-    registerParameter( dynamic_cast<Parameter *>(&pattern) );
-    registerParameter( dynamic_cast<Parameter *>(&copytype) );
-    registerParameter( dynamic_cast<Parameter *>(&prop_scale) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_y_rel) );
-    registerParameter( dynamic_cast<Parameter *>(&spacing) );
-    registerParameter( dynamic_cast<Parameter *>(&normal_offset) );
-    registerParameter( dynamic_cast<Parameter *>(&tang_offset) );
-    registerParameter( dynamic_cast<Parameter *>(&prop_units) );
-    registerParameter( dynamic_cast<Parameter *>(&vertical_pattern) );
-    registerParameter( dynamic_cast<Parameter *>(&fuse_tolerance) );
+    registerParameter(&pattern);
+    registerParameter(&copytype);
+    registerParameter(&prop_scale);
+    registerParameter(&scale_y_rel);
+    registerParameter(&spacing);
+    registerParameter(&normal_offset);
+    registerParameter(&tang_offset);
+    registerParameter(&prop_units);
+    registerParameter(&vertical_pattern);
+    registerParameter(&fuse_tolerance);
     prop_scale.param_set_digits(3);
     prop_scale.param_set_increments(0.01, 0.10);
 
diff --git a/src/live_effects/lpe-perp_bisector.cpp b/src/live_effects/lpe-perp_bisector.cpp
index bce22250a..dab169cfe 100644
--- a/src/live_effects/lpe-perp_bisector.cpp
+++ b/src/live_effects/lpe-perp_bisector.cpp
@@ -99,8 +99,8 @@ LPEPerpBisector::LPEPerpBisector(LivePathEffectObject *lpeobject) :
     _provides_knotholder_entities = true;
 
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&length_left) );
-    registerParameter( dynamic_cast<Parameter *>(&length_right) );
+    registerParameter(&length_left);
+    registerParameter(&length_right);
 }
 
 LPEPerpBisector::~LPEPerpBisector()
diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp
index 365ff5389..3cff83fed 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -110,15 +110,15 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve)
             int position_c = Geom::sgn(Geom::cross(handles[2] - handles[3], handles[0] - handles[3]));
             if (position_a != 1 && move0) {
                 Geom::Point point_a = line_a.pointAt(line_a.nearestTime(handles[0]));
-                down_left_point.param_setValue(point_a, true);
+                down_left_point.param_setValue(point_a);
             }
             if (position_b == 1 && move0) {
                 Geom::Point point_b = line_b.pointAt(line_b.nearestTime(handles[0]));
-                down_left_point.param_setValue(point_b, true);
+                down_left_point.param_setValue(point_b);
             }
             if (position_c == 1 && move0) {
                 Geom::Point point_c = line_c.pointAt(line_c.nearestTime(handles[0]));
-                down_left_point.param_setValue(point_c, true);
+                down_left_point.param_setValue(point_c);
             }
             line_a.setPoints(handles[0],handles[2]);
             line_b.setPoints(handles[2],handles[3]);
@@ -128,15 +128,15 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve)
             position_c = Geom::sgn(Geom::cross(handles[3] - handles[0], handles[1] - handles[0]));
             if (position_a != 1 && move1) {
                 Geom::Point point_a = line_a.pointAt(line_a.nearestTime(handles[1]));
-                up_left_point.param_setValue(point_a, true);
+                up_left_point.param_setValue(point_a);
             }
             if (position_b == 1 && move1) {
                 Geom::Point point_b = line_b.pointAt(line_b.nearestTime(handles[1]));
-                up_left_point.param_setValue(point_b, true);
+                up_left_point.param_setValue(point_b);
             }
             if (position_c == 1 && move1) {
                 Geom::Point point_c = line_c.pointAt(line_c.nearestTime(handles[1]));
-                up_left_point.param_setValue(point_c, true);
+                up_left_point.param_setValue(point_c);
             }
             line_a.setPoints(handles[1],handles[3]);
             line_b.setPoints(handles[3],handles[0]);
@@ -146,15 +146,15 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve)
             position_c = Geom::sgn(Geom::cross(handles[0] - handles[1], handles[2] - handles[1]));
             if (position_a != 1 && move2) {
                 Geom::Point point_a = line_a.pointAt(line_a.nearestTime(handles[2]));
-                up_right_point.param_setValue(point_a, true);
+                up_right_point.param_setValue(point_a);
             }
             if (position_b == 1 && move2) {
                 Geom::Point point_b = line_b.pointAt(line_b.nearestTime(handles[2]));
-                up_right_point.param_setValue(point_b, true);
+                up_right_point.param_setValue(point_b);
             }
             if (position_c == 1 && move2) {
                 Geom::Point point_c = line_c.pointAt(line_c.nearestTime(handles[2]));
-                up_right_point.param_setValue(point_c, true);
+                up_right_point.param_setValue(point_c);
             }
             line_a.setPoints(handles[2],handles[0]);
             line_b.setPoints(handles[0],handles[1]);
@@ -164,15 +164,15 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve)
             position_c = Geom::sgn(Geom::cross(handles[1] - handles[2], handles[3] - handles[2]));
             if (position_a != 1 && move3) {
                 Geom::Point point_a = line_a.pointAt(line_a.nearestTime(handles[3]));
-                down_right_point.param_setValue(point_a, true);
+                down_right_point.param_setValue(point_a);
             }
             if (position_b == 1 && move3) {
                 Geom::Point point_b = line_b.pointAt(line_b.nearestTime(handles[3]));
-                down_right_point.param_setValue(point_b, true);
+                down_right_point.param_setValue(point_b);
             }
             if (position_c == 1 && move3) {
                 Geom::Point point_c = line_c.pointAt(line_c.nearestTime(handles[3]));
-                down_right_point.param_setValue(point_c, true);
+                down_right_point.param_setValue(point_c);
             }
         } else {
             handles.resize(4);
@@ -434,8 +434,8 @@ LPEPerspectiveEnvelope::vertical(PointParam &param_one, PointParam &param_two, G
     }
     A[Geom::X] = nearest[Geom::X] - distance_middle;
     B[Geom::X] = nearest[Geom::X] + distance_middle;
-    param_one.param_setValue(A, true);
-    param_two.param_setValue(B, true);
+    param_one.param_setValue(A);
+    param_two.param_setValue(B);
 }
 
 void
@@ -455,8 +455,8 @@ LPEPerspectiveEnvelope::horizontal(PointParam &param_one, PointParam &param_two,
     }
     A[Geom::Y] = nearest[Geom::Y] - distance_middle;
     B[Geom::Y] = nearest[Geom::Y] + distance_middle;
-    param_one.param_setValue(A, true);
-    param_two.param_setValue(B, true);
+    param_one.param_setValue(A);
+    param_two.param_setValue(B);
 }
 
 void
diff --git a/src/live_effects/lpe-perspective_path.cpp b/src/live_effects/lpe-perspective_path.cpp
index b83fb67d7..435c91c2d 100644
--- a/src/live_effects/lpe-perspective_path.cpp
+++ b/src/live_effects/lpe-perspective_path.cpp
@@ -51,11 +51,11 @@ LPEPerspectivePath::LPEPerspectivePath(LivePathEffectObject *lpeobject) :
     uses_plane_xy(_("Uses XY plane?"), _("If true, put the path on the left side of an imaginary box, otherwise on the right side"), "uses_plane_xy", &wr, this, true)
 {
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&scalex) );
-    registerParameter( dynamic_cast<Parameter *>(&scaley) );
-    registerParameter( dynamic_cast<Parameter *>(&offsetx) );
-    registerParameter( dynamic_cast<Parameter *>(&offsety) );
-    registerParameter( dynamic_cast<Parameter *>(&uses_plane_xy) );
+    registerParameter( &scalex);
+    registerParameter( &scaley);
+    registerParameter( &offsetx);
+    registerParameter( &offsety);
+    registerParameter( &uses_plane_xy);
 
     concatenate_before_pwd2 = true; // don't split the path into its subpaths
     _provides_knotholder_entities = true;
diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp
index e9f3975c7..d87f92fcc 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -179,14 +179,14 @@ LPEPowerStroke::LPEPowerStroke(LivePathEffectObject *lpeobject) :
     interpolator_beta.addSlider(true);
     interpolator_beta.param_set_range(0.,1.);
 
-    registerParameter( dynamic_cast<Parameter *>(&offset_points) );
-    registerParameter( dynamic_cast<Parameter *>(&sort_points) );
-    registerParameter( dynamic_cast<Parameter *>(&interpolator_type) );
-    registerParameter( dynamic_cast<Parameter *>(&interpolator_beta) );
-    registerParameter( dynamic_cast<Parameter *>(&start_linecap_type) );
-    registerParameter( dynamic_cast<Parameter *>(&linejoin_type) );
-    registerParameter( dynamic_cast<Parameter *>(&miter_limit) );
-    registerParameter( dynamic_cast<Parameter *>(&end_linecap_type) );
+    registerParameter(&offset_points);
+    registerParameter(&sort_points);
+    registerParameter(&interpolator_type);
+    registerParameter(&interpolator_beta);
+    registerParameter(&start_linecap_type);
+    registerParameter(&linejoin_type);
+    registerParameter(&miter_limit);
+    registerParameter(&end_linecap_type);
 }
 
 LPEPowerStroke::~LPEPowerStroke()
diff --git a/src/live_effects/lpe-recursiveskeleton.cpp b/src/live_effects/lpe-recursiveskeleton.cpp
index aa0db920b..47613f58e 100644
--- a/src/live_effects/lpe-recursiveskeleton.cpp
+++ b/src/live_effects/lpe-recursiveskeleton.cpp
@@ -28,7 +28,7 @@ LPERecursiveSkeleton::LPERecursiveSkeleton(LivePathEffectObject *lpeobject) :
     concatenate_before_pwd2 = true;
     iterations.param_make_integer(true);
     iterations.param_set_range(1, 15);
-    registerParameter( dynamic_cast<Parameter *>(&iterations) );
+    registerParameter(&iterations);
 
 }
 
diff --git a/src/live_effects/lpe-rough-hatches.cpp b/src/live_effects/lpe-rough-hatches.cpp
index 3cc8658ea..d832b3615 100644
--- a/src/live_effects/lpe-rough-hatches.cpp
+++ b/src/live_effects/lpe-rough-hatches.cpp
@@ -241,26 +241,26 @@ LPERoughHatches::LPERoughHatches(LivePathEffectObject *lpeobject) :
 //
     bender(_("Global bending"), _("Relative position to a reference point defines global bending direction and amount"), "bender", &wr, this, Geom::Point(-5,0))
 {
-    registerParameter( dynamic_cast<Parameter *>(&direction) );
-    registerParameter( dynamic_cast<Parameter *>(&dist_rdm) );
-    registerParameter( dynamic_cast<Parameter *>(&growth) );
-    registerParameter( dynamic_cast<Parameter *>(&do_bend) );
-    registerParameter( dynamic_cast<Parameter *>(&bender) );
-    registerParameter( dynamic_cast<Parameter *>(&top_edge_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&bot_edge_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&top_tgt_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&bot_tgt_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_tf) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_tb) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_bf) );
-    registerParameter( dynamic_cast<Parameter *>(&scale_bb) );
-    registerParameter( dynamic_cast<Parameter *>(&top_smth_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&bot_smth_variation) );
-    registerParameter( dynamic_cast<Parameter *>(&fat_output) );
-    registerParameter( dynamic_cast<Parameter *>(&stroke_width_top) );
-    registerParameter( dynamic_cast<Parameter *>(&stroke_width_bot) );
-    registerParameter( dynamic_cast<Parameter *>(&front_thickness) );
-    registerParameter( dynamic_cast<Parameter *>(&back_thickness) );
+    registerParameter(&direction);
+    registerParameter(&dist_rdm);
+    registerParameter(&growth);
+    registerParameter(&do_bend);
+    registerParameter(&bender);
+    registerParameter(&top_edge_variation);
+    registerParameter(&bot_edge_variation);
+    registerParameter(&top_tgt_variation);
+    registerParameter(&bot_tgt_variation);
+    registerParameter(&scale_tf);
+    registerParameter(&scale_tb);
+    registerParameter(&scale_bf);
+    registerParameter(&scale_bb);
+    registerParameter(&top_smth_variation);
+    registerParameter(&bot_smth_variation);
+    registerParameter(&fat_output);
+    registerParameter(&stroke_width_top);
+    registerParameter(&stroke_width_bot);
+    registerParameter(&front_thickness);
+    registerParameter(&back_thickness);
 
     //hatch_dist.param_set_range(0.1, Geom::infinity());
     growth.param_set_range(0, Geom::infinity());
diff --git a/src/live_effects/lpe-ruler.cpp b/src/live_effects/lpe-ruler.cpp
index 60c2a3e1c..852592219 100644
--- a/src/live_effects/lpe-ruler.cpp
+++ b/src/live_effects/lpe-ruler.cpp
@@ -45,15 +45,15 @@ LPERuler::LPERuler(LivePathEffectObject *lpeobject) :
     offset(_("_Offset:"), _("Offset of first mark"), "offset", &wr, this, 0.0),
     border_marks(_("Border marks:"), _("Choose whether to draw marks at the beginning and end of the path"), "border_marks", BorderMarkTypeConverter, &wr, this, BORDERMARK_BOTH)
 {
-    registerParameter(dynamic_cast<Parameter *>(&unit));
-    registerParameter(dynamic_cast<Parameter *>(&mark_distance));
-    registerParameter(dynamic_cast<Parameter *>(&mark_length));
-    registerParameter(dynamic_cast<Parameter *>(&minor_mark_length));
-    registerParameter(dynamic_cast<Parameter *>(&major_mark_steps));
-    registerParameter(dynamic_cast<Parameter *>(&shift));
-    registerParameter(dynamic_cast<Parameter *>(&offset));
-    registerParameter(dynamic_cast<Parameter *>(&mark_dir));
-    registerParameter(dynamic_cast<Parameter *>(&border_marks));
+    registerParameter(&unit);
+    registerParameter(&mark_distance);
+    registerParameter(&mark_length);
+    registerParameter(&minor_mark_length);
+    registerParameter(&major_mark_steps);
+    registerParameter(&shift);
+    registerParameter(&offset);
+    registerParameter(&mark_dir);
+    registerParameter(&border_marks);
 
     major_mark_steps.param_make_integer();
     major_mark_steps.param_set_range(1, 1000);
diff --git a/src/live_effects/lpe-skeleton.cpp b/src/live_effects/lpe-skeleton.cpp
index 4fc18cee2..d3c94269a 100644
--- a/src/live_effects/lpe-skeleton.cpp
+++ b/src/live_effects/lpe-skeleton.cpp
@@ -37,7 +37,7 @@ LPESkeleton::LPESkeleton(LivePathEffectObject *lpeobject) :
     //_provides_knotholder_entities
 
     /* register all your parameters here, so Inkscape knows which parameters this effect has: */
-    registerParameter( dynamic_cast<Parameter *>(&number) );
+    registerParameter(&number);
 }
 
 LPESkeleton::~LPESkeleton()
diff --git a/src/live_effects/lpe-sketch.cpp b/src/live_effects/lpe-sketch.cpp
index e01516f2e..e3376b7e5 100644
--- a/src/live_effects/lpe-sketch.cpp
+++ b/src/live_effects/lpe-sketch.cpp
@@ -62,25 +62,25 @@ LPESketch::LPESketch(LivePathEffectObject *lpeobject) :
     // register all your parameters here, so Inkscape knows which parameters this effect has:
     //Add some comment in the UI:  *warning* the precise output of this effect might change in future releases!
     //convert to path if you want to keep exact output unchanged in future releases...
-    //registerParameter( dynamic_cast<Parameter *>(&testpointA) );
-    registerParameter( dynamic_cast<Parameter *>(&nbiter_approxstrokes) );
-    registerParameter( dynamic_cast<Parameter *>(&strokelength) );
-    registerParameter( dynamic_cast<Parameter *>(&strokelength_rdm) );
-    registerParameter( dynamic_cast<Parameter *>(&strokeoverlap) );
-    registerParameter( dynamic_cast<Parameter *>(&strokeoverlap_rdm) );
-    registerParameter( dynamic_cast<Parameter *>(&ends_tolerance) );
-    registerParameter( dynamic_cast<Parameter *>(&parallel_offset) );
-    registerParameter( dynamic_cast<Parameter *>(&tremble_size) );
-    registerParameter( dynamic_cast<Parameter *>(&tremble_frequency) );
+    //registerParameter(&testpointA) );
+    registerParameter(&nbiter_approxstrokes);
+    registerParameter(&strokelength);
+    registerParameter(&strokelength_rdm);
+    registerParameter(&strokeoverlap);
+    registerParameter(&strokeoverlap_rdm);
+    registerParameter(&ends_tolerance);
+    registerParameter(&parallel_offset);
+    registerParameter(&tremble_size);
+    registerParameter(&tremble_frequency);
 #ifdef LPE_SKETCH_USE_CONSTRUCTION_LINES
-    registerParameter( dynamic_cast<Parameter *>(&nbtangents) );
-    registerParameter( dynamic_cast<Parameter *>(&tgt_places_rdmness) );
-    registerParameter( dynamic_cast<Parameter *>(&tgtscale) );
-    registerParameter( dynamic_cast<Parameter *>(&tgtlength) );
-    registerParameter( dynamic_cast<Parameter *>(&tgtlength_rdm) );
+    registerParameter(&nbtangents);
+    registerParameter(&tgt_places_rdmness);
+    registerParameter(&tgtscale);
+    registerParameter(&tgtlength);
+    registerParameter(&tgtlength_rdm);
 #ifdef LPE_SKETCH_USE_CURVATURE
-    registerParameter( dynamic_cast<Parameter *>(&min_curvature) );
-    registerParameter( dynamic_cast<Parameter *>(&max_curvature) );
+    registerParameter(&min_curvature);
+    registerParameter(&max_curvature);
 #endif
 #endif
 
diff --git a/src/live_effects/lpe-tangent_to_curve.cpp b/src/live_effects/lpe-tangent_to_curve.cpp
index 5f63e1ee9..69a4dfad9 100644
--- a/src/live_effects/lpe-tangent_to_curve.cpp
+++ b/src/live_effects/lpe-tangent_to_curve.cpp
@@ -60,10 +60,10 @@ LPETangentToCurve::LPETangentToCurve(LivePathEffectObject *lpeobject) :
     show_orig_path = true;
     _provides_knotholder_entities = true;
 
-    registerParameter( dynamic_cast<Parameter *>(&angle) );
-    registerParameter( dynamic_cast<Parameter *>(&t_attach) );
-    registerParameter( dynamic_cast<Parameter *>(&length_left) );
-    registerParameter( dynamic_cast<Parameter *>(&length_right) );
+    registerParameter(&angle);
+    registerParameter(&t_attach);
+    registerParameter(&length_left);
+    registerParameter(&length_right);
 }
 
 LPETangentToCurve::~LPETangentToCurve()
diff --git a/src/live_effects/lpe-test-doEffect-stack.cpp b/src/live_effects/lpe-test-doEffect-stack.cpp
index 324893706..c484c88a2 100644
--- a/src/live_effects/lpe-test-doEffect-stack.cpp
+++ b/src/live_effects/lpe-test-doEffect-stack.cpp
@@ -21,12 +21,12 @@ LPEdoEffectStackTest::LPEdoEffectStackTest(LivePathEffectObject *lpeobject) :
     point(_("Point param:"), "tooltip of point parameter", "point_param", &wr, this),
     path(_("Path param:"), "tooltip of path parameter", "path_param", &wr, this,"M 0,100 100,0")
 {
-    registerParameter( dynamic_cast<Parameter *>(&step) );
-    registerParameter( dynamic_cast<Parameter *>(&point) );
-    registerParameter( dynamic_cast<Parameter *>(&path) );
+    registerParameter(&step);
+    registerParameter(&point);
+    registerParameter(&path);
 
     point.set_oncanvas_looks(SP_KNOT_SHAPE_SQUARE, SP_KNOT_MODE_XOR, 0x00ff0000);
-    point.param_setValue(point,true);
+    point.param_setValue(point);
 }
 
 LPEdoEffectStackTest::~LPEdoEffectStackTest()
diff --git a/src/live_effects/lpe-text_label.cpp b/src/live_effects/lpe-text_label.cpp
index 709d05e18..0c1db2f04 100644
--- a/src/live_effects/lpe-text_label.cpp
+++ b/src/live_effects/lpe-text_label.cpp
@@ -23,7 +23,7 @@ LPETextLabel::LPETextLabel(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     label(_("Label:"), _("Text label attached to the path"), "label", &wr, this, "This is a label")
 {
-    registerParameter( dynamic_cast<Parameter *>(&label) );
+    registerParameter(&label);
 }
 
 LPETextLabel::~LPETextLabel()
diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp
index ef2900775..f4d233d56 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -138,14 +138,22 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem)
         size_t nnodes = nodeCount(pathvector);
         first_knot.param_set_range(1, last_knot-1);
         last_knot.param_set_range(first_knot+1, nnodes);
-        from_original_width.param_setValue(false);
+        if (from_original_width){
+            from_original_width.param_setValue(false);
+        }
     } else {
-        first_knot.param_set_value(1);
-        last_knot.param_set_value(2);
+        if (first_knot != 1){
+            first_knot.param_set_value(1);
+        }
+        if (last_knot != 2){
+            last_knot.param_set_value(2);
+        }
         first_knot.param_set_range(1,1);
         last_knot.param_set_range(2,2);
-        from_original_width.param_setValue(true);
         append_path = false;
+        if (!from_original_width){
+            from_original_width.param_setValue(true);
+        }
     }
     if(lock_lenght && !lock_angle && previous_lenght != -1) {
         Geom::Ray transformed((Geom::Point)start,(Geom::Point)end);
@@ -251,6 +259,8 @@ LPETransform2Pts::reset()
         first_knot.param_set_value(1);
         last_knot.param_set_value(2);
     }
+    offset.param_set_value(0.0);
+    stretch.param_set_value(1.0);
     Geom::Ray transformed(point_a, point_b);
     previous_angle = transformed.angle();
     previous_lenght = Geom::distance(point_a, point_b);
diff --git a/src/live_effects/lpe-vonkoch.cpp b/src/live_effects/lpe-vonkoch.cpp
index 47e2a1cec..b9fd8908a 100644
--- a/src/live_effects/lpe-vonkoch.cpp
+++ b/src/live_effects/lpe-vonkoch.cpp
@@ -53,15 +53,15 @@ LPEVonKoch::LPEVonKoch(LivePathEffectObject *lpeobject) :
     maxComplexity(_("_Max complexity:"), _("Disable effect if the output is too complex"), "maxComplexity", &wr, this, 1000)
 {
     //FIXME: a path is used here instead of 2 points to work around path/point param incompatibility bug.
-    registerParameter( dynamic_cast<Parameter *>(&ref_path) );
-    //registerParameter( dynamic_cast<Parameter *>(&refA) );
-    //registerParameter( dynamic_cast<Parameter *>(&refB) );
-    registerParameter( dynamic_cast<Parameter *>(&generator) );
-    registerParameter( dynamic_cast<Parameter *>(&similar_only) );
-    registerParameter( dynamic_cast<Parameter *>(&nbgenerations) );
-    registerParameter( dynamic_cast<Parameter *>(&drawall) );
-    registerParameter( dynamic_cast<Parameter *>(&maxComplexity) );
-    //registerParameter( dynamic_cast<Parameter *>(&draw_boxes) );
+    registerParameter(&ref_path);
+    //registerParameter(&refA) );
+    //registerParameter(&refB) );
+    registerParameter(&generator);
+    registerParameter(&similar_only);
+    registerParameter(&nbgenerations);
+    registerParameter(&drawall);
+    registerParameter(&maxComplexity);
+    //registerParameter(&draw_boxes) );
     apply_to_clippath_and_mask = true;
     nbgenerations.param_make_integer();
     nbgenerations.param_set_range(0, Geom::infinity());
diff --git a/src/live_effects/parameter/array.h b/src/live_effects/parameter/array.h
index 9204ede1f..10a3ea018 100644
--- a/src/live_effects/parameter/array.h
+++ b/src/live_effects/parameter/array.h
@@ -60,7 +60,7 @@ public:
         g_strfreev (strarray);
         return true;
     }
-
+    virtual void param_update_default(const gchar * default_value){};
     virtual gchar * param_getSVGValue() const {
         Inkscape::SVGOStringStream os;
         writesvg(os, _vector);
diff --git a/src/live_effects/parameter/bool.cpp b/src/live_effects/parameter/bool.cpp
index 813c06b4e..9cb91bdd6 100644
--- a/src/live_effects/parameter/bool.cpp
+++ b/src/live_effects/parameter/bool.cpp
@@ -42,6 +42,12 @@ BoolParam::param_update_default(bool const default_value)
     defvalue = default_value;
 }
 
+void 
+BoolParam::param_update_default(const gchar * default_value)
+{
+    param_update_default(helperfns_read_bool(default_value, defvalue));
+}
+
 bool
 BoolParam::param_readSVGValue(const gchar * strvalue)
 {
@@ -72,7 +78,6 @@ BoolParam::param_newWidget()
         checkwdg->setActive(value);
         checkwdg->setProgrammatically = false;
         checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change bool parameter"));
-        param_effect->upd_params = false;
         return dynamic_cast<Gtk::Widget *> (checkwdg);
     } else {
         return NULL;
diff --git a/src/live_effects/parameter/bool.h b/src/live_effects/parameter/bool.h
index 7ad8a9368..39f328eaa 100644
--- a/src/live_effects/parameter/bool.h
+++ b/src/live_effects/parameter/bool.h
@@ -37,8 +37,8 @@ public:
     void param_setValue(bool newvalue);
     virtual void param_set_default();
     void param_update_default(bool const default_value);
+    virtual void param_update_default(const gchar * default_value);
     bool get_value() const { return value; };
-
     inline operator bool() const { return value; };
 
 private:
diff --git a/src/live_effects/parameter/enum.h b/src/live_effects/parameter/enum.h
index dbfc68623..6cadd6953 100644
--- a/src/live_effects/parameter/enum.h
+++ b/src/live_effects/parameter/enum.h
@@ -76,8 +76,17 @@ public:
     void param_set_default() {
         param_set_value(defvalue);
     }
-
+    
+    void param_update_default(E default_value) {
+        defvalue = default_value;
+    }
+    
+    virtual void param_update_default(const gchar * default_value) {
+        param_update_default(enumdataconv->get_id_from_key(Glib::ustring(default_value)));
+    }
+    
     void param_set_value(E val) {
+        param_effect->upd_params = true;
         value = val;
     }
 
diff --git a/src/live_effects/parameter/fontbutton.cpp b/src/live_effects/parameter/fontbutton.cpp
index 64c203093..5add69c1d 100644
--- a/src/live_effects/parameter/fontbutton.cpp
+++ b/src/live_effects/parameter/fontbutton.cpp
@@ -33,9 +33,11 @@ FontButtonParam::param_set_default()
 {
     param_setValue(defvalue);
 }
+
 void 
-FontButtonParam::param_update_default(const Glib::ustring default_value){
-    defvalue = default_value;
+FontButtonParam::param_update_default(const gchar * default_value)
+{
+    defvalue = (Glib::ustring)strdup(default_value);
 }
 
 bool
@@ -66,16 +68,17 @@ FontButtonParam::param_newWidget()
     Glib::ustring fontspec = param_getSVGValue();
     fontbuttonwdg->setValue( fontspec);
     fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
-    param_effect->upd_params = false;
     return dynamic_cast<Gtk::Widget *> (fontbuttonwdg);
 }
 
 void
 FontButtonParam::param_setValue(const Glib::ustring newvalue)
 {
+    param_effect->upd_params = true;
     value = newvalue;
 }
 
+
 } /* namespace LivePathEffect */
 
 } /* namespace Inkscape */
diff --git a/src/live_effects/parameter/fontbutton.h b/src/live_effects/parameter/fontbutton.h
index df47251a2..60e1aa46e 100644
--- a/src/live_effects/parameter/fontbutton.h
+++ b/src/live_effects/parameter/fontbutton.h
@@ -21,15 +21,15 @@ public:
                const Glib::ustring& key,
                Inkscape::UI::Widget::Registry* wr,
                Effect* effect,
-               const Glib::ustring default_value = "");
+               const Glib::ustring default_value = "Sans 10");
     virtual ~FontButtonParam() {}
 
     virtual Gtk::Widget * param_newWidget();
     virtual bool param_readSVGValue(const gchar * strvalue);
-    void param_update_default(const Glib::ustring defvalue);
+    void param_update_default(const gchar * default_value);
     virtual gchar * param_getSVGValue() const;
 
-    void param_setValue(const Glib::ustring newvalue);
+    void param_setValue(Glib::ustring newvalue);
     
     virtual void param_set_default();
 
diff --git a/src/live_effects/parameter/item.cpp b/src/live_effects/parameter/item.cpp
index 93cf2b15f..7b40f4540 100644
--- a/src/live_effects/parameter/item.cpp
+++ b/src/live_effects/parameter/item.cpp
@@ -60,6 +60,10 @@ ItemParam::param_set_default()
     param_readSVGValue(defvalue);
 }
 
+void
+ItemParam::param_update_default(const gchar * default_value){
+    defvalue = strdup(default_value);
+}
 
 void
 ItemParam::param_set_and_write_default()
diff --git a/src/live_effects/parameter/item.h b/src/live_effects/parameter/item.h
index 6c719d451..89c32f9bd 100644
--- a/src/live_effects/parameter/item.h
+++ b/src/live_effects/parameter/item.h
@@ -36,6 +36,7 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     virtual void param_set_default();
+    virtual void param_update_default(const gchar * default_value);
     void param_set_and_write_default();
     virtual void addCanvasIndicators(SPLPEItem const* lpeitem, std::vector<Geom::PathVector> &hp_vec);
 
diff --git a/src/live_effects/parameter/originalpatharray.h b/src/live_effects/parameter/originalpatharray.h
index 296c0f7f7..fe9371644 100644
--- a/src/live_effects/parameter/originalpatharray.h
+++ b/src/live_effects/parameter/originalpatharray.h
@@ -65,12 +65,11 @@ public:
     virtual bool param_readSVGValue(const gchar * strvalue);
     virtual gchar * param_getSVGValue() const;
     virtual void param_set_default();
-    
+    virtual void param_update_default(const gchar * default_value){};
     /** Disable the canvas indicators of parent class by overriding this method */
     virtual void param_editOncanvas(SPItem * /*item*/, SPDesktop * /*dt*/) {};
     /** Disable the canvas indicators of parent class by overriding this method */
     virtual void addCanvasIndicators(SPLPEItem const* /*lpeitem*/, std::vector<Geom::PathVector> & /*hp_vec*/) {};
-    
     std::vector<PathAndDirection*> _vector;
     
 protected:
diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index befac4df1..1c1063960 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -39,6 +39,7 @@ Parameter::Parameter( const Glib::ustring& label, const Glib::ustring& tip,
 void
 Parameter::param_write_to_repr(const char * svgd)
 {
+    param_effect->upd_params = true;
     param_effect->getRepr()->setAttribute(param_key.c_str(), svgd);
 }
 
@@ -107,6 +108,16 @@ ScalarParam::param_update_default(gdouble default_value)
     defvalue = default_value;
 }
 
+void 
+ScalarParam::param_update_default(const gchar * default_value)
+{
+    double newval;
+    unsigned int success = sp_svg_number_read_d(default_value, &newval);
+    if (success == 1) {
+        param_update_default(newval);
+    }
+}
+
 void
 ScalarParam::param_set_value(gdouble val)
 {
@@ -128,7 +139,6 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     // Once again, in gtk2, this is not a problem. But in gtk3,
     // widgets get allocated the amount of size they ask for,
     // leading to excessively long widgets.
-    param_effect->upd_params = true;
     if (min >= -SCALARPARAM_G_MAXDOUBLE) {
         this->min = min;
     } else {
@@ -145,7 +155,6 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
 void
 ScalarParam::param_make_integer(bool yes)
 {
-    param_effect->upd_params = true;
     integer = yes;
     digits = 0;
     inc_step = 1;
@@ -176,7 +185,6 @@ ScalarParam::param_newWidget()
         if(!overwrite_widget){
             rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
         }
-        param_effect->upd_params = false;
         return dynamic_cast<Gtk::Widget *> (rsu);
     } else {
         return NULL;
@@ -186,14 +194,12 @@ ScalarParam::param_newWidget()
 void
 ScalarParam::param_set_digits(unsigned digits)
 {
-    param_effect->upd_params = true;
     this->digits = digits;
 }
 
 void
 ScalarParam::param_set_increments(double step, double page)
 {
-    param_effect->upd_params = true;
     inc_step = step;
     inc_page = page;
 }
diff --git a/src/live_effects/parameter/parameter.h b/src/live_effects/parameter/parameter.h
index 6cf10710c..ee1d2d547 100644
--- a/src/live_effects/parameter/parameter.h
+++ b/src/live_effects/parameter/parameter.h
@@ -60,7 +60,7 @@ public:
     void write_to_SVG();
  
     virtual void param_set_default() = 0;
-
+    virtual void param_update_default(const gchar * default_value) = 0;
     // This creates a new widget (newed with Gtk::manage(new ...);)
     virtual Gtk::Widget * param_newWidget() = 0;
 
@@ -77,6 +77,7 @@ public:
     virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/) {};
 
     Glib::ustring param_key;
+    Glib::ustring param_tooltip;
     Inkscape::UI::Widget::Registry * param_wr;
     Glib::ustring param_label;
 
@@ -84,7 +85,6 @@ public:
     bool widget_is_visible;
 
 protected:
-    Glib::ustring param_tooltip;
 
     Effect* param_effect;
 
@@ -112,6 +112,7 @@ public:
 
     virtual void param_set_default();
     void param_update_default(gdouble default_value);
+    virtual void param_update_default(const gchar * default_value);
     void param_set_value(gdouble val);
     void param_make_integer(bool yes = true);
     void param_set_range(gdouble min, gdouble max);
@@ -120,7 +121,6 @@ public:
     void addSlider(bool add_slider_widget) { add_slider = add_slider_widget; };
     double param_get_max() { return max; };
     double param_get_min() { return min; };
-
     void param_overwrite_widget(bool overwrite_widget);
     virtual Gtk::Widget * param_newWidget();
 
diff --git a/src/live_effects/parameter/path.cpp b/src/live_effects/parameter/path.cpp
index dafc6d406..aa87508ab 100644
--- a/src/live_effects/parameter/path.cpp
+++ b/src/live_effects/parameter/path.cpp
@@ -439,6 +439,10 @@ PathParam::linked_modified_callback(SPObject *linked_obj, guint /*flags*/)
     SP_OBJECT(param_effect->getLPEObj())->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
 
+void
+PathParam::param_update_default(const gchar * default_value){
+    defvalue = strdup(default_value);
+}
 
 /* CALLBACK FUNCTIONS FOR THE BUTTONS */
 void
diff --git a/src/live_effects/parameter/path.h b/src/live_effects/parameter/path.h
index d2dddbe97..5381a6b36 100644
--- a/src/live_effects/parameter/path.h
+++ b/src/live_effects/parameter/path.h
@@ -40,6 +40,7 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     virtual void param_set_default();
+    virtual void param_update_default(const gchar * default_value);
     void param_set_and_write_default();
     void set_new_value (Geom::PathVector const &newpath, bool write_to_svg);
     void set_new_value (Geom::Piecewise<Geom::D2<Geom::SBasis> > const &newpath, bool write_to_svg);
diff --git a/src/live_effects/parameter/point.cpp b/src/live_effects/parameter/point.cpp
index c87b1e299..4ca88a6b8 100644
--- a/src/live_effects/parameter/point.cpp
+++ b/src/live_effects/parameter/point.cpp
@@ -26,8 +26,7 @@ PointParam::PointParam( const Glib::ustring& label, const Glib::ustring& tip,
     :   Parameter(label, tip, key, wr, effect), 
         defvalue(default_value),
         liveupdate(live_update),
-        knoth(NULL),
-        _pointwdg(NULL)
+        knoth(NULL)
 {
     knot_shape = SP_KNOT_SHAPE_DIAMOND;
     knot_mode  = SP_KNOT_MODE_XOR;
@@ -59,12 +58,25 @@ PointParam::param_get_default() const{
 }
 
 void
-PointParam::param_update_default(const Geom::Point default_point)
+PointParam::param_update_default(Geom::Point default_point)
 {
     defvalue = default_point;
 }
 
 void
+PointParam::param_update_default(const gchar * default_point)
+{
+    gchar ** strarray = g_strsplit(default_point, ",", 2);
+    double newx, newy;
+    unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+    success += sp_svg_number_read_d(strarray[1], &newy);
+    g_strfreev (strarray);
+    if (success == 2) {
+        param_update_default( Geom::Point(newx, newy) );
+    }
+}
+
+void
 PointParam::param_setValue(Geom::Point newpoint, bool write)
 {
     *dynamic_cast<Geom::Point *>( this ) = newpoint;
@@ -78,9 +90,6 @@ PointParam::param_setValue(Geom::Point newpoint, bool write)
     if(knoth && liveupdate){
         knoth->update_knots();
     }
-    if (_pointwdg) {
-        _pointwdg->setValue( newpoint );
-    }
 }
 
 bool
@@ -116,7 +125,7 @@ PointParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
 Gtk::Widget *
 PointParam::param_newWidget()
 {
-    _pointwdg = Gtk::manage(
+    Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg = Gtk::manage(
         new Inkscape::UI::Widget::RegisteredTransformedPoint( param_label,
                                                               param_tooltip,
                                                               param_key,
@@ -125,15 +134,14 @@ PointParam::param_newWidget()
                                                               param_effect->getSPDoc() ) );
     Geom::Affine transf = Geom::Scale(1, -1);
     transf[5] = SP_ACTIVE_DOCUMENT->getHeight().value("px");
-    _pointwdg->setTransform(transf);
-    _pointwdg->setValue( *this );
-    _pointwdg->clearProgrammatically();
-    _pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
+    pointwdg->setTransform(transf);
+    pointwdg->setValue( *this );
+    pointwdg->clearProgrammatically();
+    pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
 
     Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
-    static_cast<Gtk::HBox*>(hbox)->pack_start(*_pointwdg, true, true);
+    static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
     static_cast<Gtk::HBox*>(hbox)->show_all_children();
-    param_effect->upd_params = false;
     return dynamic_cast<Gtk::Widget *> (hbox);
 }
 
@@ -173,7 +181,7 @@ PointParamKnotHolderEntity::knot_set(Geom::Point const &p, Geom::Point const &or
             s = A;
         }
     }
-    pparam->param_setValue(s, this->pparam->liveupdate);
+    pparam->param_setValue(s);
     SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
     if(splpeitem && this->pparam->liveupdate){
         sp_lpe_item_update_patheffect(splpeitem, false, false);
diff --git a/src/live_effects/parameter/point.h b/src/live_effects/parameter/point.h
index e8cb66225..a5153ad80 100644
--- a/src/live_effects/parameter/point.h
+++ b/src/live_effects/parameter/point.h
@@ -43,14 +43,15 @@ public:
     void param_set_default();
     Geom::Point param_get_default() const;
     void param_set_liveupdate(bool live_update);
-    void param_update_default(const Geom::Point default_point);
+    void param_update_default(Geom::Point default_point);
+
+    virtual void param_update_default(const gchar * default_point);
     virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
 
     void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
 
     virtual bool providesKnotHolderEntities() const { return true; }
     virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
-
     friend class PointParamKnotHolderEntity;
 private:
     PointParam(const PointParam&);
@@ -62,7 +63,6 @@ private:
     SPKnotModeType knot_mode;
     guint32 knot_color;
     gchar *handle_tip;
-    Inkscape::UI::Widget::RegisteredTransformedPoint * _pointwdg;
 };
 
 
diff --git a/src/live_effects/parameter/powerstrokepointarray.h b/src/live_effects/parameter/powerstrokepointarray.h
index 56a609fa8..a34163ca1 100644
--- a/src/live_effects/parameter/powerstrokepointarray.h
+++ b/src/live_effects/parameter/powerstrokepointarray.h
@@ -39,13 +39,13 @@ public:
 
     virtual bool providesKnotHolderEntities() const { return true; }
     virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
+    virtual void param_update_default(const gchar * default_value){};
 
     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; }
     Geom::Piecewise<Geom::D2<Geom::SBasis> > const & get_pwd2_normal() const { return last_pwd2_normal; }
 
     void recalculate_controlpoints_for_new_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
-
     friend class PowerStrokePointArrayParamKnotHolderEntity;
 
 private:
diff --git a/src/live_effects/parameter/random.cpp b/src/live_effects/parameter/random.cpp
index 075e85ee1..90e53ca0e 100644
--- a/src/live_effects/parameter/random.cpp
+++ b/src/live_effects/parameter/random.cpp
@@ -78,6 +78,20 @@ RandomParam::param_set_default()
 }
 
 void
+RandomParam::param_update_default(gdouble default_value){
+    defvalue = default_value;
+}
+
+void
+RandomParam::param_update_default(const gchar * default_value){
+    double newval;
+    unsigned int success = sp_svg_number_read_d(default_value, &newval);
+    if (success == 1) {
+        param_update_default(newval);
+    }
+}
+
+void
 RandomParam::param_set_value(gdouble val, long newseed)
 {
     value = val;
diff --git a/src/live_effects/parameter/random.h b/src/live_effects/parameter/random.h
index ca4440336..5fb6027ac 100644
--- a/src/live_effects/parameter/random.h
+++ b/src/live_effects/parameter/random.h
@@ -38,9 +38,9 @@ public:
     void param_set_value(gdouble val, long newseed);
     void param_make_integer(bool yes = true);
     void param_set_range(gdouble min, gdouble max);
-
+    void param_update_default(gdouble default_value);
+    virtual void param_update_default(const gchar * default_value);
     void resetRandomizer();
-
     operator gdouble();
     inline gdouble get_value() { return value; } ;
 
diff --git a/src/live_effects/parameter/text.cpp b/src/live_effects/parameter/text.cpp
index 5c4cdf4c6..4062a4dc7 100644
--- a/src/live_effects/parameter/text.cpp
+++ b/src/live_effects/parameter/text.cpp
@@ -50,9 +50,9 @@ TextParam::param_set_default()
 }
 
 void
-TextParam::param_update_default(Glib::ustring default_value)
+TextParam::param_update_default(const gchar * default_value)
 {
-    defvalue = default_value;
+    defvalue = (Glib::ustring)default_value;
 }
 
 void
@@ -125,14 +125,12 @@ TextParam::param_newWidget()
     rsu->setProgrammatically = false;
 
     rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change text parameter"));
-    param_effect->upd_params = false;
     return dynamic_cast<Gtk::Widget *> (rsu);
 }
 
 void
 TextParam::param_setValue(const Glib::ustring newvalue)
 {
-    param_effect->upd_params = true;
     value = newvalue;
     if (!_hide_canvas_text) {
         sp_canvastext_set_text (canvas_text, newvalue.c_str());
diff --git a/src/live_effects/parameter/text.h b/src/live_effects/parameter/text.h
index 553c84c0a..137f3ee02 100644
--- a/src/live_effects/parameter/text.h
+++ b/src/live_effects/parameter/text.h
@@ -39,16 +39,16 @@ public:
     virtual bool param_readSVGValue(const gchar * strvalue);
     virtual gchar * param_getSVGValue() const;
 
-    void param_setValue(const Glib::ustring newvalue);
+    void param_setValue(Glib::ustring newvalue);
     void param_hide_canvas_text();
     virtual void param_set_default();
-    void param_update_default(Glib::ustring default_value);
+    virtual void param_update_default(const gchar * default_value);
     void setPos(Geom::Point pos);
     void setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
 			 const double t, const double length, bool use_curvature = false);
     void setAnchor(double x_value, double y_value);
 
-    const Glib::ustring get_value() const { return defvalue; };
+    const Glib::ustring get_value() const { return value; };
 
 private:
     TextParam(const TextParam&);
diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp
index b3f6442bb..9eb89fea5 100644
--- a/src/live_effects/parameter/togglebutton.cpp
+++ b/src/live_effects/parameter/togglebutton.cpp
@@ -60,6 +60,18 @@ ToggleButtonParam::param_getSVGValue() const
     return str;
 }
 
+void 
+ToggleButtonParam::param_update_default(bool default_value)
+{
+    defvalue = default_value;
+}
+
+void 
+ToggleButtonParam::param_update_default(const gchar * default_value)
+{
+    param_update_default(helperfns_read_bool(default_value, defvalue));
+}
+
 Gtk::Widget *
 ToggleButtonParam::param_newWidget()
 {
@@ -68,7 +80,7 @@ ToggleButtonParam::param_newWidget()
     }
 
    checkwdg = Gtk::manage(
-        new Inkscape::UI::Widget::RegisteredToggleButton( param_label,
+        new Inkscape::UI::Widget::RegisteredToggleButton(param_label,
                                                          param_tooltip,
                                                          param_key,
                                                          *param_wr,
@@ -112,7 +124,6 @@ ToggleButtonParam::param_newWidget()
     checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
 
     _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
-    param_effect->upd_params = false;
     return checkwdg;
 }
 
@@ -153,14 +164,13 @@ ToggleButtonParam::refresh_button()
 void
 ToggleButtonParam::param_setValue(bool newvalue)
 {
+    param_effect->upd_params = true;
     value = newvalue;
     refresh_button();
 }
 
 void
 ToggleButtonParam::toggled() {
-    //Force redraw for update widgets
-    param_effect->upd_params = true;
     if (SP_ACTIVE_DESKTOP) {
         Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
         selection->emitModified();
diff --git a/src/live_effects/parameter/togglebutton.h b/src/live_effects/parameter/togglebutton.h
index 8390fec86..d6ca15e75 100644
--- a/src/live_effects/parameter/togglebutton.h
+++ b/src/live_effects/parameter/togglebutton.h
@@ -51,6 +51,8 @@ public:
     
     sigc::signal<void>& signal_toggled() { return _signal_toggled; }
     virtual void toggled();
+    void param_update_default(bool default_value);
+    virtual void param_update_default(const gchar * default_value);
 
 private:
     ToggleButtonParam(const ToggleButtonParam&);
diff --git a/src/live_effects/parameter/transformedpoint.cpp b/src/live_effects/parameter/transformedpoint.cpp
index 0d03432c3..22d5ba3a4 100644
--- a/src/live_effects/parameter/transformedpoint.cpp
+++ b/src/live_effects/parameter/transformedpoint.cpp
@@ -82,6 +82,25 @@ TransformedPointParam::param_getSVGValue() const
     return str;
 }
 
+void
+TransformedPointParam::param_update_default(Geom::Point default_point)
+{
+    defvalue = default_point;
+}
+
+void
+TransformedPointParam::param_update_default(const gchar * default_point)
+{
+    gchar ** strarray = g_strsplit(default_point, ",", 2);
+    double newx, newy;
+    unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+    success += sp_svg_number_read_d(strarray[1], &newy);
+    g_strfreev (strarray);
+    if (success == 2) {
+        param_update_default( Geom::Point(newx, newy) );
+    }
+}
+
 Gtk::Widget *
 TransformedPointParam::param_newWidget()
 {
diff --git a/src/live_effects/parameter/transformedpoint.h b/src/live_effects/parameter/transformedpoint.h
index c96bedb53..269cc508e 100644
--- a/src/live_effects/parameter/transformedpoint.h
+++ b/src/live_effects/parameter/transformedpoint.h
@@ -51,7 +51,9 @@ public:
 
     void set_vector_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
     void set_oncanvas_color(guint32 color);
-
+    Geom::Point param_get_default() { return defvalue; }
+    void param_update_default(Geom::Point default_point);
+    virtual void param_update_default(const gchar * default_point);
     virtual bool providesKnotHolderEntities() const { return true; }
     virtual void addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item);
 
diff --git a/src/live_effects/parameter/unit.cpp b/src/live_effects/parameter/unit.cpp
index b6ea99bfe..b9b91c1e6 100644
--- a/src/live_effects/parameter/unit.cpp
+++ b/src/live_effects/parameter/unit.cpp
@@ -55,14 +55,15 @@ UnitParam::param_set_default()
 }
 
 void 
-UnitParam::param_update_default(const Glib::ustring default_unit)
+UnitParam::param_update_default(const gchar * default_unit)
 {
-    defunit = unit_table.getUnit(default_unit);
+    defunit = unit_table.getUnit((Glib::ustring)default_unit);
 }
 
 void
 UnitParam::param_set_value(Inkscape::Util::Unit const &val)
 {
+    param_effect->upd_params = true;
     unit = new Inkscape::Util::Unit(val);
 }
 
diff --git a/src/live_effects/parameter/unit.h b/src/live_effects/parameter/unit.h
index ae58cf956..c662b6edc 100644
--- a/src/live_effects/parameter/unit.h
+++ b/src/live_effects/parameter/unit.h
@@ -33,11 +33,10 @@ public:
     virtual gchar * param_getSVGValue() const;
     virtual void param_set_default();
     void param_set_value(Inkscape::Util::Unit const &val);
-    void param_update_default(const Glib::ustring default_unit);
+    virtual void param_update_default(const gchar * default_unit);
     const gchar *get_abbreviation() const;
-
     virtual Gtk::Widget * param_newWidget();
-
+    
     operator Inkscape::Util::Unit const *() const { return unit; }
 
 private:
diff --git a/src/live_effects/parameter/vector.cpp b/src/live_effects/parameter/vector.cpp
index 55b4d4b32..470fa9c2d 100644
--- a/src/live_effects/parameter/vector.cpp
+++ b/src/live_effects/parameter/vector.cpp
@@ -48,6 +48,25 @@ VectorParam::param_set_default()
     setVector(defvalue);
 }
 
+void
+VectorParam::param_update_default(Geom::Point default_point)
+{
+    defvalue = default_point;
+}
+
+void
+VectorParam::param_update_default(const gchar * default_point)
+{
+    gchar ** strarray = g_strsplit(default_point, ",", 2);
+    double newx, newy;
+    unsigned int success = sp_svg_number_read_d(strarray[0], &newx);
+    success += sp_svg_number_read_d(strarray[1], &newy);
+    g_strfreev (strarray);
+    if (success == 2) {
+        param_update_default( Geom::Point(newx, newy) );
+    }
+}
+
 bool
 VectorParam::param_readSVGValue(const gchar * strvalue)
 {
diff --git a/src/live_effects/parameter/vector.h b/src/live_effects/parameter/vector.h
index edee4ff4d..d270e9f43 100644
--- a/src/live_effects/parameter/vector.h
+++ b/src/live_effects/parameter/vector.h
@@ -51,7 +51,8 @@ public:
     void set_vector_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
     void set_origin_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
     void set_oncanvas_color(guint32 color);
-
+    void param_update_default(Geom::Point default_point);
+    virtual void param_update_default(const gchar * default_point);
     virtual bool providesKnotHolderEntities() const { return true; }
     virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);