Allow set and reset default values of LPE parameters

(bzr r15620.1.1)

74 files changed, 980 insertions, 365 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 017947cda..23af55cb3 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -74,72 +74,73 @@
 #include "xml/sp-css-attr.h"
 #include "live_effects/lpeobject.h"
 #include "display/curve.h"
-
+#include <stdio.h>
+#include <string.h>
 
 namespace Inkscape {
 
 namespace LivePathEffect {
-
+const Glib::ustring DEFAULT_PREF_VALUE = "--default";
 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"},
-    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),          "fillet-chamfer"},
+    {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"},
+    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
 #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"},
+    {MEASURE_LINE,          N_("Measure Line"),                    "measure_line"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -350,6 +351,7 @@ Effect::Effect(LivePathEffectObject *lpeobject)
     : apply_to_clippath_and_mask(false),
       _provides_knotholder_entities(false),
       oncanvasedit_it(0),
+      show_default_widgets(true),
       is_visible(_("Is visible?"), _("If unchecked, the effect remains applied to the object but is temporarily disabled on canvas"), "is_visible", &wr, this, true),
       show_orig_path(false),
       erase_extra_objects(true),
@@ -644,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();
@@ -654,10 +657,18 @@ 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 prefs_path = (Glib::ustring)"/live_effects/" +
+                                       (Glib::ustring)LPETypeConverter.get_key(effectType()).c_str() +
+                                       (Glib::ustring)"/" + 
+                                       (Glib::ustring)key;
+            bool valid = prefs->getEntry(prefs_path).isValid();
+            //add to preferences-skeleton the parameters you want reseteable
+            if(valid  && prefs->getString(prefs_path) != DEFAULT_PREF_VALUE){
+                param->param_update_default(prefs->getString(prefs_path).c_str());
+            } else {
+                param->param_set_default();
+            }
         }
-
         ++it;
     }
 }
@@ -667,6 +678,7 @@ void
 Effect::setParameter(const gchar * key, const gchar * new_value)
 {
     Parameter * param = getParameter(key);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     if (param) {
         if (new_value) {
             bool accepted = param->param_readSVGValue(new_value);
@@ -674,7 +686,6 @@ Effect::setParameter(const gchar * key, const gchar * new_value)
                 g_warning("Effect::setParameter - '%s' not accepted for %s", new_value, key);
             }
         } else {
-            // set default value
             param->param_set_default();
         }
     }
@@ -773,6 +784,21 @@ Effect::newWidget()
         ++it;
     }
     upd_params = false;
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &Effect::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &Effect::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -867,6 +893,45 @@ Effect::resetDefaults(SPItem const* /*item*/)
 }
 
 void
+Effect::setDefaultParams()
+{
+    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();
+        Glib::ustring prefs_path = (Glib::ustring)"/live_effects/" +
+                                   (Glib::ustring)LPETypeConverter.get_key(effectType()).c_str() +
+                                   (Glib::ustring)"/" + 
+                                   (Glib::ustring)key;
+        bool valid = prefs->getEntry(prefs_path).isValid();
+        if (valid){
+            prefs->setString(prefs_path, (Glib::ustring)param->param_getSVGValue());
+        }
+        ++it;
+    }
+}
+
+void 
+Effect::resetDefaultParams(){
+    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();
+        Glib::ustring prefs_path = (Glib::ustring)"/live_effects/" +
+                                   (Glib::ustring)LPETypeConverter.get_key(effectType()).c_str() +
+                                   (Glib::ustring)"/" + 
+                                   (Glib::ustring)key;
+        bool valid = prefs->getEntry(prefs_path).isValid();
+        if (valid){
+            prefs->setString(prefs_path, DEFAULT_PREF_VALUE);
+        }
+        ++it;
+    }
+}
+
+void
 Effect::transform_multiply(Geom::Affine const& postmul, bool set)
 {
     // cycle through all parameters. Most parameters will not need transformation, but path and point params do.
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index f5e41d50e..c509db387 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -136,6 +136,7 @@ public:
     bool upd_params;
     BoolParam is_visible;
     SPCurve * sp_curve;
+
     Geom::PathVector pathvector_before_effect;
 protected:
     Effect(LivePathEffectObject *lpeobject);
@@ -156,12 +157,14 @@ protected:
     virtual void addKnotHolderEntities(KnotHolder * /*knotholder*/, SPItem * /*item*/) {};
 
     virtual void addCanvasIndicators(SPLPEItem const* lpeitem, std::vector<Geom::PathVector> &hp_vec);
-
     std::vector<Parameter *> param_vector;
+    void setDefaultParams();
+    void resetDefaultParams();
+
     bool _provides_knotholder_entities;
 
     int oncanvasedit_it;
-
+    bool show_default_widgets;
     bool show_orig_path; // set this to true in derived effects to automatically have the original
                          // path displayed as helperpath
 
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 1423e670a..fb803b770 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -139,6 +139,22 @@ Gtk::Widget *LPEBSpline::newWidget()
 
         ++it;
     }
+    Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEBSpline::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEBSpline::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
diff --git a/src/live_effects/lpe-clone-original.cpp b/src/live_effects/lpe-clone-original.cpp
index c41b1ef95..74f93eddc 100644
--- a/src/live_effects/lpe-clone-original.cpp
+++ b/src/live_effects/lpe-clone-original.cpp
@@ -323,6 +323,21 @@ 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);
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPECloneOriginal::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPECloneOriginal::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     this->upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
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..a462c76a6 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -332,6 +332,21 @@ Gtk::Widget * LPECopyRotate::newWidget()
 
         ++it;
     }
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPECopyRotate::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPECopyRotate::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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 1e2df7dc8..f21b53f90 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -176,7 +176,21 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
 
     vbox->pack_start(*filletContainer, true, true, 2);
     vbox->pack_start(*chamferContainer, true, true, 2);
-
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return vbox;
 }
 
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-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp
index e827491c0..fe01ef9ee 100644
--- a/src/live_effects/lpe-lattice2.cpp
+++ b/src/live_effects/lpe-lattice2.cpp
@@ -256,12 +256,27 @@ LPELattice2::newWidget()
 
         ++it;
     }
-
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPELattice2::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPELattice2::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show Points"))));
     expander->add(*vbox_expander);
     expander->set_expanded(expanded);
     vbox->pack_start(*expander, true, true, 2);
     expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::onExpanderChanged) );
+    
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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..1095cfc0d 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);
@@ -622,6 +606,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 +632,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 +692,56 @@ 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);
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
@@ -766,31 +762,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..a00aac3be 100644
--- a/src/live_effects/lpe-mirror_symmetry.cpp
+++ b/src/live_effects/lpe-mirror_symmetry.cpp
@@ -336,6 +336,21 @@ LPEMirrorSymmetry::newWidget()
         ++it;
     }
     this->upd_params = false;
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameterss")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMirrorSymmetry::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMirrorSymmetry::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
diff --git a/src/live_effects/lpe-offset.cpp b/src/live_effects/lpe-offset.cpp
index 057f404e0..c853e4afa 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()
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..e967a01aa 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -414,6 +414,21 @@ LPEPerspectiveEnvelope::newWidget()
     reset_button->set_size_request(140,30);
     vbox->pack_start(*hbox, true,true,2);
     hbox->pack_start(*reset_button, false, false,2);
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEPerspectiveEnvelope::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEPerspectiveEnvelope::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index e847494a2..8b2a07d59 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -163,6 +163,21 @@ Gtk::Widget *LPERoughen::newWidget()
         }
         ++it;
     }
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPERoughen::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPERoughen::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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-simplify.cpp b/src/live_effects/lpe-simplify.cpp
index 5de9816bb..5b5bbea6c 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -115,6 +115,21 @@ LPESimplify::newWidget()
         ++it;
     }
     vbox->pack_start(*buttons,true, true, 2);
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPESimplify::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPESimplify::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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..e5bc8657d 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -350,6 +350,21 @@ Gtk::Widget *LPETransform2Pts::newWidget()
     vbox->pack_start(*button2, true, true, 2);
     vbox->pack_start(*button3, true, true, 2);
     vbox->pack_start(*button4, true, true, 2);
+    if (show_default_widgets) {
+        Gtk::Label *default_label = Gtk::manage(new Gtk::Label(
+                                                Glib::ustring(_("<b>Defaults</b> set defaultable parameters")),
+                                                Gtk::ALIGN_START));
+        default_label->set_use_markup(true);
+        vbox->pack_start(*default_label, true, true, 2);
+        Gtk::HBox * defaultBox = Gtk::manage(new Gtk::HBox(true,0));
+        Gtk::Button *set_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Set"))));
+        set_default->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::setDefaultParams));
+        Gtk::Button *reset_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset"))));
+        reset_default->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::resetDefaultParams));
+        defaultBox->pack_start(*set_default, true, true, 2);
+        defaultBox->pack_start(*reset_default, true, true, 2);
+        vbox->pack_start(*defaultBox, true, true, 2);
+    }
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
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 a600f0257..fa08e1f91 100644
--- a/src/live_effects/parameter/array.h
+++ b/src/live_effects/parameter/array.h
@@ -59,7 +59,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..cdc988ab2 100644
--- a/src/live_effects/parameter/bool.cpp
+++ b/src/live_effects/parameter/bool.cpp
@@ -37,11 +37,17 @@ BoolParam::param_set_default()
 }
 
 void 
-BoolParam::param_update_default(bool const default_value)
+BoolParam::param_update_default(bool 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)
 {
diff --git a/src/live_effects/parameter/bool.h b/src/live_effects/parameter/bool.h
index 7ad8a9368..a96966c46 100644
--- a/src/live_effects/parameter/bool.h
+++ b/src/live_effects/parameter/bool.h
@@ -36,9 +36,9 @@ public:
 
     void param_setValue(bool newvalue);
     virtual void param_set_default();
-    void param_update_default(bool const default_value);
+    void param_update_default(bool 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..0bb2d89b2 100644
--- a/src/live_effects/parameter/enum.h
+++ b/src/live_effects/parameter/enum.h
@@ -76,7 +76,15 @@ 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) {
         value = val;
     }
diff --git a/src/live_effects/parameter/filletchamferpointarray.h b/src/live_effects/parameter/filletchamferpointarray.h
index b81339a69..4e4268703 100644
--- a/src/live_effects/parameter/filletchamferpointarray.h
+++ b/src/live_effects/parameter/filletchamferpointarray.h
@@ -55,6 +55,7 @@ public:
     virtual void set_chamfer_steps(int value_chamfer_steps);
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
                                      std::vector<Geom::PathVector> &hp_vec);
+    virtual void param_update_default(const gchar * default_value){};
     virtual bool providesKnotHolderEntities() const {
         return true;
     }
diff --git a/src/live_effects/parameter/fontbutton.cpp b/src/live_effects/parameter/fontbutton.cpp
index 64c203093..53b8c0612 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
@@ -63,7 +65,7 @@ FontButtonParam::param_newWidget()
                                                         *param_wr,
                                                         param_effect->getRepr(),
                                                         param_effect->getSPDoc() ) );
-    Glib::ustring fontspec = param_getSVGValue();
+    Glib::ustring fontspec = (Glib::ustring)param_getSVGValue();
     fontbuttonwdg->setValue( fontspec);
     fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
     param_effect->upd_params = false;
@@ -71,11 +73,12 @@ FontButtonParam::param_newWidget()
 }
 
 void
-FontButtonParam::param_setValue(const Glib::ustring newvalue)
+FontButtonParam::param_setValue(Glib::ustring newvalue)
 {
     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/originalitem.h b/src/live_effects/parameter/originalitem.h
index 58d04e05a..de1a6ac25 100644
--- a/src/live_effects/parameter/originalitem.h
+++ b/src/live_effects/parameter/originalitem.h
@@ -26,7 +26,6 @@ public:
     void setInverse(bool inversed) { inverse = inversed; }
     bool linksToItem() const { return (href != NULL); }
     SPItem * getObject() const { return ref.getObject(); }
-
     virtual Gtk::Widget * param_newWidget();
 
 protected:
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..15c81d543 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -107,6 +107,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)
 {
diff --git a/src/live_effects/parameter/parameter.h b/src/live_effects/parameter/parameter.h
index 6cf10710c..e94737a6f 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;
 
@@ -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..683cadc1f 100644
--- a/src/live_effects/parameter/point.cpp
+++ b/src/live_effects/parameter/point.cpp
@@ -59,12 +59,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;
diff --git a/src/live_effects/parameter/point.h b/src/live_effects/parameter/point.h
index e8cb66225..a3797aea5 100644
--- a/src/live_effects/parameter/point.h
+++ b/src/live_effects/parameter/point.h
@@ -43,14 +43,14 @@ 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&);
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..8d526e4cc 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
@@ -130,7 +130,7 @@ TextParam::param_newWidget()
 }
 
 void
-TextParam::param_setValue(const Glib::ustring newvalue)
+TextParam::param_setValue(Glib::ustring newvalue)
 {
     param_effect->upd_params = true;
     value = newvalue;
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..4eaa1aeb2 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()
 {
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..b78b75dbf 100644
--- a/src/live_effects/parameter/unit.cpp
+++ b/src/live_effects/parameter/unit.cpp
@@ -55,9 +55,9 @@ 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
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);
 
diff --git a/src/preferences-skeleton.h b/src/preferences-skeleton.h
index ed00092b2..44775988c 100644
--- a/src/preferences-skeleton.h
+++ b/src/preferences-skeleton.h
@@ -72,6 +72,316 @@ static char const preferences_skeleton[] =
 "       inkscape:window-width=\"640\"\n"
 "       inkscape:window-height=\"480\" />\n"
 "  </group>\n"
+"  <group id=\"live_effects\">\n"
+"    <sodipodi:namedview\n"
+"       id=\"measure_line\"\n"
+"       unit=\"px\"\n"
+"       fontbutton=\"Sans 10\"\n"
+"       orientation=\"OM_PARALLEL\"\n"
+"       precision=\"2\"\n"
+"       position=\"5\"\n"
+"       text_top_bottom=\"0\"\n"
+"       text_right_left=\"0\"\n"
+"       helpline_distance=\"0\"\n"
+"       helpline_overlap=\"2.0\"\n"
+"       scale=\"1.0\"\n"
+"       format=\"{measure}{unit}\"\n"
+"       arrows_outside=\"false\"\n"
+"       flip_side=\"false\"\n"
+"       scale_sensitive=\"true\"\n"
+"       local_locale=\"true\"\n"
+"       line_group_05=\"true\"\n"
+"       rotate_anotation=\"true\"\n"
+"       hide_back=\"true\"\n"
+"       dimline_format=\"\"\n"
+"       helperlines_format=\"\"\n"
+"       anotation_format=\"\"\n"
+"       arrows_format=\"\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"bend_path\"\n"
+"       prop_scale=\"1.0\"\n"
+"       scale_y_rel=\"false\"\n"
+"       vertical_pattern=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"bounding_box\"\n"
+"       visual_bounds=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"bspline\"\n"
+"       steps=\"2\"\n"
+"       helper_size=\"0\"\n"
+"       apply_no_weight=\"true\"\n"
+"       apply_with_weight=\"true\"\n"
+"       only_selected=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"clone_original\"\n"
+"       scale=\"100.0\"\n"
+"       attributes=\"\"\n"
+"       style_attributes=\"\"\n"
+"       preserve_position=\"false\"\n"
+"       inverse=\"false\"\n"
+"       d=\"true\"\n"
+"       transform=\"true\"\n"
+"       fill=\"false\"\n"
+"       stroke=\"false\"\n"
+"       paintorder=\"false\"\n"
+"       opacity=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"construct_grid\"\n"
+"       nr_x=\"5\"\n"
+"       nr_y=\"5\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"copy_rotate\"\n"
+"       copies_to_360=\"true\"\n"
+"       fuse_paths=\"false\"\n"
+"       join_paths=\"false\"\n"
+"       split_items=\"false\"\n"
+"       starting_angle=\"0.0\"\n"
+"       rotation_angle=\"60.0\"\n"
+"       num_copies=\"6\"\n"
+"       split_gap=\"-0.001\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"curvestitching\"\n"
+"       nrofpaths=\"5\"\n"
+"       startpoint_edge_variation=\"0\"\n"
+"       startpoint_spacing_variation=\"0\"\n"
+"       endpoint_edge_variation=\"0\"\n"
+"       endpoint_spacing_variation=\"0.0\"\n"
+"       prop_scale=\"1\"\n"
+"       scale_y_rel=\"0\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"envelope\"\n"
+"       yy=\"true\"\n"
+"       xx=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"fill_between_many\"\n"
+"       fuse=\"false\"\n"
+"       allow_transforms=\"false\"\n"
+"       join=\"true\"\n"
+"       close=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"fill_between_strokes\"\n"
+"       reverse_second=\"false\"\n"
+"       fuse=\"false\"\n"
+"       allow_transforms=\"false\"\n"
+"       join=\"true\"\n"
+"       close=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"fillet_chamfer\"\n"
+"       method=\"FM_AUTO\"\n"
+"       radius=\"0.0\"\n"
+"       chamfer_steps=\"0\"\n"
+"       helper_size=\"0\"\n"
+"       flexible=\"false\"\n"
+"       use_knot_distance=\"false\"\n"
+"       ignore_radius_0=\"false\"\n"
+"       only_selected=\"false\"\n"
+"       hide_knots=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"gears\"\n"
+"       teeth=\"10\"\n"
+"       phi=\"5\"\n"
+"       min_radius=\"5.0\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"interpolate\"\n"
+"       equidistant_spacing=\"true\"\n"
+"       number_of_steps=\"5\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"join_type\"\n"
+"       linecap_type=\"butt_straight\"\n"
+"       linejoin_type=\"JOIN_EXTRAPOLATE\"\n"
+"       miter_limit=\"100.\"\n"
+"       attempt_force_join=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"knot\"\n"
+"       interruption_width=\"3.0\"\n"
+"       prop_to_stroke_width=\"true\"\n"
+"       add_stroke_width=\"true\"\n"
+"       add_other_stroke_width=\"true\"\n"
+"       switcher_size=\"15\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"lattice2\"\n"
+"       horizontal_mirror=\"false\"\n"
+"       vertical_mirror=\"false\"\n"
+"       live_update=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"line_segment\"\n"
+"       end_type=\"END_OPEN_BOTH\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"mirror_symmetry\"\n"
+"       mode=\"MT_FREE\"\n"
+"       split_gap=\"-0.001\"\n"
+"       discard_orig_path=\"false\"\n"
+"       fuse_paths=\"false\"\n"
+"       oposite_fuse=\"false\"\n"
+"       split_items=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"parallel\"\n"
+"       length_left=\"150\"\n"
+"       length_right=\"150\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"path_length\"\n"
+"       scale=\"1.0\"\n"
+"       info_text=\"\"\n"
+"       unit=\"\"\n"
+"       display_unit=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"skeletal\"\n"
+"       copytype=\"PAPCT_SINGLE_STRETCHED\"\n"
+"       prop_scale=\"1.0\"\n"
+"       scale_y_rel=\"false\"\n"
+"       spacing=\"0\"\n"
+"       normal_offset=\"0\"\n"
+"       tang_offset=\"0\"\n"
+"       prop_units=\"false\"\n"
+"       vertical_pattern=\"false\" \n"
+"       fuse_tolerance=\"0\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"perp_bisector\"\n"
+"       length_left=\"200\"\n"
+"       length_right=\"200\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"perspective-envelope\"\n"
+"       deform_type=\"DEFORMATION_PERSPECTIVE\"\n"
+"       horizontal_mirror=\"false\"\n"
+"       vertical_mirror=\"false\"\n"
+"       overflow_perspective=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"perspective_path\"\n"
+"       scalex=\"1.0\"\n"
+"       scaley=\"1.0\"\n"
+"       offsetx=\"0.0\"\n"
+"       offsety=\"0.0\"\n"
+"       uses_plane_xy=\"true\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"powerstroke\"\n"
+"       sort_points=\"true\"\n"
+"       interpolator_type=\"Geom::Interpolate::INTERP_CUBICBEZIER\"\n"
+"       interpolator_beta=\"0.2\"\n"
+"       start_linecap_type=\"LINECAP_BUTT\"\n"
+"       linejoin_type=\"LINEJOIN_EXTRP_MITER_ARC\"\n"
+"       miter_limit=\"4.0\"\n"
+"       end_linecap_type=\"LINECAP_BUTT\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"recursive_skeleton\"\n"
+"       iterations=\"2\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"roughen\"\n"
+"       method=\"DM_SEGMENTS\"\n"
+"       max_segment_size=\"10\"\n"
+"       segments=\"2\"\n"
+"       displace_x=\"10.0\"\n"
+"       displace_y=\"10.0\"\n"
+"       global_randomize=\"1.0\"\n"
+"       handles=\"HM_ALONG_NODES\"\n"
+"       shift_nodes=\"true\" \n"
+"       fixed_displacement=\"false\"\n"
+"       spray_tool_friendly=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"rough_hatches\"\n"
+"       direction=\"Geom::Point(50,0)\"\n"
+"       dist_rdm=\"75\"\n"
+"       growth=\"1.0\"\n"
+"       do_bend=\"true\"\n"
+"       bender=\"Geom::Point(-5,0)\"\n"
+"       top_edge_variation=\"0\"\n"
+"       bot_edge_variation=\"0\"\n"
+"       top_tgt_variation=\"0\"\n"
+"       bot_tgt_variation=\"0\"\n"
+"       scale_tf=\"1.0\"\n"
+"       scale_tb=\"1.0\"\n"
+"       scale_bf=\"1.0\"\n"
+"       scale_bb=\"1.0\"\n"
+"       top_smth_variation=\"0\"\n"
+"       bot_smth_variation=\"0\"\n"
+"       fat_output=\"true\"\n"
+"       stroke_width_top=\"1.0\"\n"
+"       stroke_width_bot=\"1.0\"\n"
+"       front_thickness=\"1.0\"\n"
+"       back_thickness=\"0.25\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"ruler\"\n"
+"       unit=\"\"\n"
+"       mark_distance=\"20.0\"\n"
+"       mark_length=\"14\"\n"
+"       minor_mark_length=\"7.0\"\n"
+"       major_mark_steps=\"5\"\n"
+"       shift=\"0\"\n"
+"       offset=\"0.0\"\n"
+"       mark_dir=\"MARKDIR_LEFT\" \n"
+"       border_marks=\"BORDERMARK_BOTH\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"show_handles\"\n"
+"       nodes=\"true\"\n"
+"       handles=\"true\"\n"
+"       original_path=\"true\"\n"
+"       show_center_node=\"false\"\n"
+"       scale_nodes_and_handles=\"10\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"simplify\"\n"
+"       steps=\"1\"\n"
+"       threshold=\"0.002\"\n"
+"       smooth_angles=\"0.0\"\n"
+"       helper_size=\"5\"\n"
+"       simplify_individual_paths=\"false\"\n"
+"       simplify_just_coalesce=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"sketch\"\n"
+"       nbiter_approxstrokes=\"5\"\n"
+"       strokelength=\"100\"\n"
+"       strokelength_rdm=\"0.3\"\n"
+"       strokeoverlap=\"0.3\"\n"
+"       strokeoverlap_rdm=\"0.3\"\n"
+"       ends_tolerance=\"0.1\"\n"
+"       parallel_offset=\"5.0\"\n"
+"       tremble_size=\"5.0\"\n"
+"       tremble_frequency=\"1.0\"\n"
+"       nbtangents=\"5\"\n"
+"       tgt_places_rdmness=\"1.0\"\n"
+"       tgtscale=\"10.0\"\n"
+"       tgtlength=\"100.0\"\n"
+"       tgtlength_rdm=\"0.3\"\n"
+"       min_curvature=\"4.0\"\n"
+"       max_curvature=\"1000.0\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"tangent_to_curve\"\n"
+"       angle=\"0.0\"\n"
+"       t_attach=\"0.5\"\n"
+"       length_left=\"150\"\n"
+"       length_right=\"150\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"taper_stroke\"\n"
+"       attach_start=\"0.2\"\n"
+"       attach_end=\"0.2\"\n"
+"       smoothing=\"0.5\"\n"
+"       join_type=\"JOIN_EXTRAPOLATE\"\n"
+"       miter_limit=\"100.0\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"doeffectstacktest\"\n"
+"       step=\"\"\n"
+"       point=\"\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"transform_2pts\"\n"
+"       first_knot=\"1\"\n"
+"       last_knot=\"1\"\n"
+"       helper_size=\"3\"\n"
+"       stretch=\"1.0\"\n"
+"       offset=\"0.0\"\n"
+"       elastic=\"false\"\n"
+"       from_original_width=\"false\"\n"
+"       flip_vertical=\"false\"\n"
+"       flip_horizontal=\"false\"\n"
+"       lock_lenght=\"false\"\n"
+"       lock_angle=\"false\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"vonkoch\"\n"
+"       similar_only=\"false\"\n"
+"       nb_generations=\"1\"\n"
+"       drawall=\"true\"\n"
+"       maxComplexity=\"1000\" />\n"
+"    <sodipodi:namedview\n"
+"       id=\"interpolate_points\"\n"
+"       interpolator_type=\"Geom::Interpolate::INTERP_CENTRIPETAL_CATMULLROM\" />\n"
+"  </group>\n"
 "\n"
 "  <group id=\"tools\"\n"
 "         bounding_box=\"0\">\n"