Merge jabier's Measure line LPE

(bzr r15148)

42 files changed, 1542 insertions, 93 deletions

diff --git a/src/live_effects/CMakeLists.txt b/src/live_effects/CMakeLists.txt
index 9a2f06a76..784317090 100644
--- a/src/live_effects/CMakeLists.txt
+++ b/src/live_effects/CMakeLists.txt
@@ -27,6 +27,7 @@ set(live_effects_SRC
 	lpe-lattice.cpp
 	lpe-lattice2.cpp
 	lpe-line_segment.cpp
+	lpe-measure-line.cpp
 	lpe-mirror_symmetry.cpp
 	lpe-offset.cpp
 	lpe-parallel.cpp
@@ -68,6 +69,7 @@ set(live_effects_SRC
 	parameter/powerstrokepointarray.cpp
 	parameter/random.cpp
 	parameter/text.cpp
+	parameter/fontbutton.cpp
 	parameter/togglebutton.cpp
 	parameter/transformedpoint.cpp
 	parameter/unit.cpp
@@ -105,6 +107,7 @@ set(live_effects_SRC
 	lpe-lattice.h
 	lpe-lattice2.h
 	lpe-line_segment.h
+	lpe-measure-line.h
 	lpe-mirror_symmetry.h
 	lpe-offset.h
 	lpe-parallel.h
@@ -148,6 +151,7 @@ set(live_effects_SRC
 	parameter/powerstrokepointarray.h
 	parameter/random.h
 	parameter/text.h
+	parameter/fontbutton.h
 	parameter/togglebutton.h
 	parameter/transformedpoint.h
 	parameter/unit.h
diff --git a/src/live_effects/effect-enum.h b/src/live_effects/effect-enum.h
index eea26184c..3682aa1bd 100644
--- a/src/live_effects/effect-enum.h
+++ b/src/live_effects/effect-enum.h
@@ -36,6 +36,7 @@ enum EffectType {
     CONSTRUCT_GRID,
     PERP_BISECTOR,
     TANGENT_TO_CURVE,
+    MEASURE_LINE,
     MIRROR_SYMMETRY,
     CIRCLE_3PTS,
     TRANSFORM_2PTS,
diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 007a8ca38..792bb5d7a 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -39,6 +39,7 @@
 #include "live_effects/lpe-lattice2.h"
 #include "live_effects/lpe-lattice.h"
 #include "live_effects/lpe-line_segment.h"
+#include "live_effects/lpe-measure-line.h"
 #include "live_effects/lpe-mirror_symmetry.h"
 #include "live_effects/lpe-offset.h"
 #include "live_effects/lpe-parallel.h"
@@ -135,6 +136,8 @@ const Util::EnumData<EffectType> LPETypeData[] = {
     {FILL_BETWEEN_MANY,     N_("Fill between many"),       "fill_between_many"},
     {ELLIPSE_5PTS,          N_("Ellipse by 5 points"),     "ellipse_5pts"},
     {BOUNDING_BOX,          N_("Bounding Box"),            "bounding_box"},
+/* 9.93 */
+    {MEASURE_LINE,          N_("Measure Line"),            "measure-line"},
 };
 const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
 
@@ -303,6 +306,9 @@ Effect::New(EffectType lpenr, LivePathEffectObject *lpeobj)
         case TRANSFORM_2PTS:
             neweffect = static_cast<Effect*> ( new LPETransform2Pts(lpeobj) );
             break;
+        case MEASURE_LINE:
+            neweffect = static_cast<Effect*> ( new LPEMeasureLine(lpeobj) );
+            break;
         default:
             g_warning("LivePathEffect::Effect::New called with invalid patheffect type (%d)", lpenr);
             neweffect = NULL;
@@ -348,6 +354,7 @@ Effect::Effect(LivePathEffectObject *lpeobject)
       concatenate_before_pwd2(false),
       sp_lpe_item(NULL),
       current_zoom(1),
+      upd_params(true),
       sp_curve(NULL),
       provides_own_flash_paths(true), // is automatically set to false if providesOwnFlashPaths() is not overridden
       is_ready(false) // is automatically set to false if providesOwnFlashPaths() is not overridden
@@ -431,7 +438,9 @@ void Effect::doAfterEffect (SPLPEItem const* /*lpeitem*/)
 void Effect::doOnRemove (SPLPEItem const* /*lpeitem*/)
 {
 }
-
+void Effect::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
+{
+}
 //secret impl methods (shhhh!)
 void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
 {
@@ -690,7 +699,7 @@ Effect::newWidget()
 
         ++it;
     }
-
+    upd_params = false;
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index 840f723fa..5ca53486c 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -66,7 +66,7 @@ public:
     
     virtual void doAfterEffect (SPLPEItem const* lpeitem);
     virtual void doOnRemove (SPLPEItem const* lpeitem);
-
+    virtual void doOnVisibilityToggled(SPLPEItem const* lpeitem);
     void writeParamsToSVG();
 
     virtual void acceptParamPath (SPPath const* param_path);
@@ -123,6 +123,7 @@ public:
 
     void editNextParamOncanvas(SPItem * item, SPDesktop * desktop);
     bool apply_to_clippath_and_mask;
+    bool upd_params;
 
 protected:
     Effect(LivePathEffectObject *lpeobject);
diff --git a/src/live_effects/lpe-ellipse_5pts.cpp b/src/live_effects/lpe-ellipse_5pts.cpp
index 8f0f8e18a..0371fc313 100644
--- a/src/live_effects/lpe-ellipse_5pts.cpp
+++ b/src/live_effects/lpe-ellipse_5pts.cpp
@@ -170,7 +170,7 @@ LPEEllipse5Pts::doEffect_path (Geom::PathVector const & path_in)
 
     // figure out if we have a slice, guarding against rounding errors
 
-    Path p(Geom::Point(cos(0), sin(0)));
+    Geom::Path p(Geom::Point(cos(0), sin(0)));
 
     double end = 2 * M_PI;
     for (s = 0; s < end; s += M_PI_2) {
diff --git a/src/live_effects/lpe-extrude.cpp b/src/live_effects/lpe-extrude.cpp
index 22cdf3c3e..d22007f76 100644
--- a/src/live_effects/lpe-extrude.cpp
+++ b/src/live_effects/lpe-extrude.cpp
@@ -61,7 +61,7 @@ LPEExtrude::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2
     using namespace Geom;
 
     // generate connecting lines (the 'sides' of the extrusion)
-    Path path(Point(0.,0.));
+    Geom::Path path(Point(0.,0.));
     path.appendNew<Geom::LineSegment>( extrude_vector.getVector() );
     Piecewise<D2<SBasis> > connector = path.toPwSb();
 
diff --git a/src/live_effects/lpe-knot.cpp b/src/live_effects/lpe-knot.cpp
index 221d03ebf..fbc32cf3e 100644
--- a/src/live_effects/lpe-knot.cpp
+++ b/src/live_effects/lpe-knot.cpp
@@ -94,7 +94,7 @@ findShadowedTime(Geom::Path const &patha, std::vector<Geom::Point> const &pt_and
 
     Affine mat = from_basis( T, N, pt_and_dir[0] );
     mat = mat.inverse();
-    Path p = patha * mat;
+    Geom::Path p = patha * mat;
     
     std::vector<double> times;
     
@@ -477,7 +477,7 @@ LPEKnot::doEffect_path (Geom::PathVector const &path_in)
 //                std::cout<<"fusing first and last component\n";
                 ++beg_comp;
                 --end_comp;
-                Path first = gpaths[i0].portion(dom.back());
+                Geom::Path first = gpaths[i0].portion(dom.back());
                 //FIXME: stitching should not be necessary (?!?)
                 first.setStitching(true);
                 first.append(gpaths[i0].portion(dom.front()));
diff --git a/src/live_effects/lpe-measure-line.cpp b/src/live_effects/lpe-measure-line.cpp
new file mode 100644
index 000000000..e8ceb7e51
--- /dev/null
+++ b/src/live_effects/lpe-measure-line.cpp
@@ -0,0 +1,892 @@
+/*
+ * Author(s):
+ *   Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ * Some code and ideas migrated from dimensioning.py by
+ * Johannes B. Rutzmoser, johannes.rutzmoser (at) googlemail (dot) com
+ * https://github.com/Rutzmoser/inkscape_dimensioning
+ * Copyright (C) 2014 Author(s)
+
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include "live_effects/lpe-measure-line.h"
+#include <pangomm/fontdescription.h>
+#include "ui/dialog/livepatheffect-editor.h"
+#include <libnrtype/font-lister.h>
+#include "inkscape.h"
+#include "xml/node.h"
+#include "uri.h"
+#include "uri-references.h"
+#include "preferences.h"
+#include "util/units.h"
+#include "svg/svg-length.h"
+#include "svg/svg-color.h"
+#include "svg/svg.h"
+#include "display/curve.h"
+#include "2geom/affine.h"
+#include "style.h"
+#include "sp-root.h"
+#include "sp-defs.h"
+#include "sp-item.h"
+#include "sp-shape.h"
+#include "sp-path.h"
+#include "desktop.h"
+#include "document.h"
+#include <iomanip>
+
+// TODO due to internal breakage in glibmm headers, this must be last:
+#include <glibmm/i18n.h>
+
+using namespace Geom;
+namespace Inkscape {
+namespace LivePathEffect {
+
+static const Util::EnumData<OrientationMethod> OrientationMethodData[] = {
+    { OM_HORIZONTAL, N_("Horizontal"), "horizontal" }, 
+    { OM_VERTICAL, N_("Vertical"), "vertical" },
+    { OM_PARALLEL, N_("Parallel"), "parallel" }
+};
+static const Util::EnumDataConverter<OrientationMethod> OMConverter(OrientationMethodData, OM_END);
+
+LPEMeasureLine::LPEMeasureLine(LivePathEffectObject *lpeobject) :
+    Effect(lpeobject),
+    unit(_("Unit*"), _("Unit"), "unit", &wr, this, "px"),
+    fontbutton(_("Font*"), _("Font Selector"), "fontbutton", &wr, this),
+    orientation(_("Orientation"), _("Orientation method"), "orientation", OMConverter, &wr, this, OM_PARALLEL, false),
+    curve_linked(_("Curve on origin"), _("Curve on origin, set 0 to start/end"), "curve_linked", &wr, this, 1),
+    precision(_("Precision*"), _("Precision"), "precision", &wr, this, 2),
+    position(_("Positon*"), _("Positon"), "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"),
+    arrows_outside(_("Arrows outside"), _("Arrows outside"), "arrows_outside", &wr, this, false),
+    flip_side(_("Flip side*"), _("Flip side"), "flip_side", &wr, this, false),
+    scale_insensitive(_("Scale insensitive*"), _("Scale insensitive to transforms in element, parents..."), "scale_insensitive", &wr, this, true),
+    local_locale(_("Local Number Format*"), _("Local number format"), "local_locale", &wr, this, true),
+    line_group_05(_("Line Group 0.5*"), _("Line Group 0.5, from 0.7"), "line_group_05", &wr, this, true),
+    rotate_anotation(_("Rotate Anotation*"), _("Rotate Anotation"), "rotate_anotation", &wr, this, true),
+    hide_back(_("Hide if label over*"), _("Hide DIN line if label over"), "hide_back", &wr, this, true),
+    dimline_format(_("CSS DIN line*"), _("Override CSS to DIN line, return to save, empty to reset to DIM"), "dimline_format", &wr, this,""),
+    helperlines_format(_("CSS helpers*"), _("Override CSS to helper lines, return to save, empty to reset to DIM"), "helperlines_format", &wr, this,""),
+    anotation_format(_("CSS anotation*"), _("Override CSS to anotation text, return to save, empty to reset to DIM"), "anotation_format", &wr, this,""),
+    arrows_format(_("CSS arrows*"), _("Override CSS to arrows, return to save, empty to reset DIM"), "arrows_format", &wr, this,""),
+    expanded(false)
+{
+    registerParameter(&unit);
+    registerParameter(&fontbutton);
+    registerParameter(&orientation);
+    registerParameter(&curve_linked);
+    registerParameter(&precision);
+    registerParameter(&position);
+    registerParameter(&text_top_bottom);
+    registerParameter(&text_right_left);
+    registerParameter(&helpline_distance);
+    registerParameter(&helpline_overlap);
+    registerParameter(&scale);
+    registerParameter(&format);
+    registerParameter(&arrows_outside);
+    registerParameter(&flip_side);
+    registerParameter(&scale_insensitive);
+    registerParameter(&local_locale);
+    registerParameter(&line_group_05);
+    registerParameter(&rotate_anotation);
+    registerParameter(&hide_back);
+    registerParameter(&dimline_format);
+    registerParameter(&helperlines_format);
+    registerParameter(&anotation_format);
+    registerParameter(&arrows_format);
+    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_insensitive.param_update_default(prefs->getBool("/live_effects/measure-line/scale_insensitive"));
+    local_locale.param_update_default(prefs->getBool("/live_effects/measure-line/local_locale"));
+    line_group_05.param_update_default(prefs->getBool("/live_effects/measure-line/line_group_05"));
+    rotate_anotation.param_update_default(prefs->getBool("/live_effects/measure-line/rotate_anotation"));
+    hide_back.param_update_default(prefs->getBool("/live_effects/measure-line/hide_back"));
+    format.param_hide_canvas_text();
+    dimline_format.param_hide_canvas_text();
+    helperlines_format.param_hide_canvas_text();
+    anotation_format.param_hide_canvas_text();
+    arrows_format.param_hide_canvas_text();
+    precision.param_set_range(0, 100);
+    precision.param_set_increments(1, 1);
+    precision.param_set_digits(0);
+    precision.param_make_integer(true);
+    curve_linked.param_set_range(0, 999);
+    curve_linked.param_set_increments(1, 1);
+    curve_linked.param_set_digits(0);
+    curve_linked.param_make_integer(true);
+    precision.param_make_integer(true);
+    position.param_set_range(-999999.0, 999999.0);
+    position.param_set_increments(1, 1);
+    position.param_set_digits(2);
+    text_top_bottom.param_set_range(-999999.0, 999999.0);
+    text_top_bottom.param_set_increments(1, 1);
+    text_top_bottom.param_set_digits(2);
+    text_right_left.param_set_range(-999999.0, 999999.0);
+    text_right_left.param_set_increments(1, 1);
+    text_right_left.param_set_digits(2);
+    helpline_distance.param_set_range(-999999.0, 999999.0);
+    helpline_distance.param_set_increments(1, 1);
+    helpline_distance.param_set_digits(2);
+    helpline_overlap.param_set_range(-999999.0, 999999.0);
+    helpline_overlap.param_set_increments(1, 1);
+    helpline_overlap.param_set_digits(2);
+    erase = true;
+}
+
+LPEMeasureLine::~LPEMeasureLine() {}
+
+void swap(Geom::Point &A, Geom::Point &B){
+    Geom::Point tmp = A;
+    A = B;
+    B = tmp;
+}
+void
+LPEMeasureLine::doOnApply(SPLPEItem const* lpeitem)
+{
+    if (!SP_IS_SHAPE(lpeitem)) {
+        g_warning("LPE measure line can only be applied to shapes (not groups).");
+        SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+        item->removeCurrentPathEffect(false);
+    }
+}
+
+void
+LPEMeasureLine::doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/)
+{
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" +  (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        Inkscape::XML::Node *node = NULL;
+        if (elemref = SVGElemRef->getObject()) {
+            node = elemref->getRepr();
+            if (!this->isVisible()) {
+                node->setAttribute("style", "display:none");
+            } else {
+                node->setAttribute("style", NULL);
+            }
+        }
+        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" +  (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri2);
+        if (elemref = SVGElemRef->getObject()) {
+            node = elemref->getRepr();
+            if (!this->isVisible()) {
+                node->setAttribute("style", "display:none");
+            } else {
+                node->setAttribute("style", NULL);
+            }
+        }
+        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" +  (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri3);
+        if (elemref = SVGElemRef->getObject()) {
+            node = elemref->getRepr();
+            if (!this->isVisible()) {
+                node->setAttribute("style", "display:none");
+            } else {
+                node->setAttribute("style", NULL);
+            }
+        }
+        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" +  (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri4);
+        if (elemref = SVGElemRef->getObject()) {
+            node = elemref->getRepr();
+            if (!this->isVisible()) {
+                node->setAttribute("style", "display:none");
+            } else {
+                node->setAttribute("style", NULL);
+            }
+        }
+        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" +  (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri5);
+        if (elemref = SVGElemRef->getObject()) {
+            node = elemref->getRepr();
+            if (!this->isVisible()) {
+                node->setAttribute("style", "display:none");
+            } else {
+                node->setAttribute("style", NULL);
+            }
+        }
+    }
+}
+
+void
+LPEMeasureLine::createArrowMarker(Glib::ustring mode)
+{
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + mode).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        Inkscape::XML::Node *arrow = NULL;
+        if (!(elemref = SVGElemRef->getObject())) {
+            arrow = xml_doc->createElement("svg:marker");
+            arrow->setAttribute("id", mode.c_str());
+            arrow->setAttribute("inkscape:stockid", mode.c_str());
+            arrow->setAttribute("orient", "auto");
+            arrow->setAttribute("refX", "0.0");
+            arrow->setAttribute("refY", "0.0");
+            arrow->setAttribute("style", "overflow:visible");
+            arrow->setAttribute("sodipodi:insensitive", "true");
+            /* Create <path> */
+            Inkscape::XML::Node *arrow_path = xml_doc->createElement("svg:path");
+            if (mode == (Glib::ustring)"ArrowDIN-start") {
+                arrow_path->setAttribute("d", "M -8,0 8,-2.11 8,2.11 z");
+            } else if (mode == (Glib::ustring)"ArrowDIN-end") {
+                arrow_path->setAttribute("d", "M 8,0 -8,2.11 -8,-2.11 z");
+            } else if (mode == (Glib::ustring)"ArrowDINout-start") {
+                arrow_path->setAttribute("d", "M 0,0 -16,2.11 -16,0.5 -26,0.5 -26,-0.5 -16,-0.5 -16,-2.11 z");
+            } else {
+                arrow_path->setAttribute("d", "M 0,0 16,2.11 16,0.5 26,0.5 26,-0.5 16,-0.5 16,-2.11 z");
+            }
+            
+            arrow_path->setAttribute("id", (mode + (Glib::ustring)"_path").c_str());
+            SPCSSAttr *css = sp_repr_css_attr_new();
+            sp_repr_css_set_property (css, "fill","#000000");
+            sp_repr_css_set_property (css, "stroke","none" );
+            sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
+            Glib::ustring css_str;
+            sp_repr_css_write_string(css,css_str);
+            arrow_path->setAttribute("style", css_str.c_str());
+            arrow->addChild(arrow_path, NULL);
+            Inkscape::GC::release(arrow_path);
+            elemref = SP_OBJECT(desktop->getDocument()->getDefs()->appendChildRepr(arrow));
+            Inkscape::GC::release(arrow);
+        } else {
+            Inkscape::XML::Node *arrow= elemref->getRepr();
+            if (arrow) {
+                arrow->setAttribute("sodipodi:insensitive", "true");
+                Inkscape::XML::Node *arrow_data = arrow->firstChild();
+                if (arrow_data) {
+                    SPCSSAttr *css = sp_repr_css_attr_new();
+                    sp_repr_css_set_property (css, "fill","#000000");
+                    sp_repr_css_set_property (css, "stroke","none" );
+                    sp_repr_css_attr_add_from_string(css, arrows_format.param_getSVGValue());
+                    Glib::ustring css_str;
+                    sp_repr_css_write_string(css,css_str);
+                    arrow_data->setAttribute("style", css_str.c_str());
+                }
+            }
+        }
+    }
+}
+
+void
+LPEMeasureLine::createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove)
+{
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+        Inkscape::XML::Node *rtext = NULL;
+        double doc_w = desktop->getDocument()->getRoot()->width.value;
+        Geom::Scale scale = desktop->getDocument()->getDocumentScale();
+        SPNamedView *nv = desktop->getNamedView();
+        Glib::ustring display_unit = nv->display_units->abbr;
+        if (display_unit.empty()) {
+            display_unit = "px";
+        }
+        //only check constrain viewbox on X
+        doc_scale = Inkscape::Util::Quantity::convert( scale[Geom::X], "px", nv->display_units );
+        if( doc_scale > 0 ) {
+            doc_scale= 1.0/doc_scale;
+        } else {
+            doc_scale = 1.0;
+        }
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" +  (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        Inkscape::XML::Node *rtspan = NULL;
+        
+        if (elemref = SVGElemRef->getObject()) {
+            if (remove) {
+                elemref->deleteObject();
+                return;
+            }
+            pos = pos - Point::polar(angle, text_right_left);
+            rtext = elemref->getRepr();
+            sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
+            sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
+            rtext->setAttribute("sodipodi:insensitive", "true");
+        } else {
+            if (remove) {
+                return;
+            }
+            rtext = xml_doc->createElement("svg:text");
+            rtext->setAttribute("xml:space", "preserve");
+            rtext->setAttribute("id", ( (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+            rtext->setAttribute("sodipodi:insensitive", "true");
+            pos = pos - Point::polar(angle, text_right_left);
+            sp_repr_set_svg_double(rtext, "x", pos[Geom::X]);
+            sp_repr_set_svg_double(rtext, "y", pos[Geom::Y]);
+            rtspan = xml_doc->createElement("svg:tspan");
+            rtspan->setAttribute("sodipodi:role", "line");
+        }
+        gchar * transform;
+        Geom::Affine affine = Geom::Affine(Geom::Translate(pos).inverse());
+        angle = std::fmod(angle, 2*M_PI);
+        if (angle < 0) angle += 2*M_PI;
+        if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
+            angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
+            if (angle < 0) angle += 2*M_PI;
+        }
+        affine *= Geom::Rotate(angle);
+        affine *= Geom::Translate(pos);
+        if (rotate_anotation) {
+            transform = sp_svg_transform_write(affine);
+        } else {
+            transform = NULL;
+        }
+        rtext->setAttribute("transform", transform);
+        SPCSSAttr *css = sp_repr_css_attr_new();
+        sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
+        Inkscape::FontLister *fontlister = Inkscape::FontLister::get_instance();
+        fontlister->fill_css( css, (Glib::ustring)fontbutton.param_getSVGValue() );
+        std::stringstream font_size;
+        font_size.imbue(std::locale::classic());
+        font_size <<  fontsize << "pt";
+
+        sp_repr_css_set_property (css, "font-size",font_size.str().c_str());
+        sp_repr_css_set_property (css, "line-height","125%");
+        sp_repr_css_set_property (css, "letter-spacing","0");
+        sp_repr_css_set_property (css, "word-spacing", "0");
+        sp_repr_css_set_property (css, "text-align", "center");
+        sp_repr_css_set_property (css, "text-anchor", "middle");
+        sp_repr_css_set_property (css, "fill", "#000000");
+        sp_repr_css_set_property (css, "fill-opacity", "1");
+        sp_repr_css_set_property (css, "stroke", "none");
+        sp_repr_css_attr_add_from_string(css, anotation_format.param_getSVGValue());
+        Glib::ustring css_str;
+        sp_repr_css_write_string(css,css_str);
+        if (!rtspan) {
+            rtspan = rtext->firstChild();
+        }
+        rtext->setAttribute("style", css_str.c_str());
+        rtspan->setAttribute("style", NULL);
+        sp_repr_css_attr_unref (css);
+        if (!elemref) {
+            rtext->addChild(rtspan, NULL);
+            Inkscape::GC::release(rtspan);
+        }
+        length = Inkscape::Util::Quantity::convert(length / doc_scale, display_unit.c_str(), unit.get_abbreviation());
+        std::stringstream length_str;
+        length_str.precision(precision);
+        length_str.setf(std::ios::fixed, std::ios::floatfield);
+        if (local_locale) {
+            length_str.imbue(std::locale(""));
+        } else {
+            length_str.imbue(std::locale::classic());
+        }
+        length_str << std::fixed << length;
+        Glib::ustring label_value = Glib::ustring(format.param_getSVGValue());
+        size_t s = label_value.find((Glib::ustring)"{measure}",0);
+        if(s < label_value.length()) {
+            label_value.replace(s,s+9,length_str.str());
+        }
+        s = label_value.find((Glib::ustring)"{unit}",0);
+        if(s < label_value.length()) {
+            label_value.replace(s,s+6,unit.get_abbreviation());
+        }
+        Inkscape::XML::Node *rstring = NULL;
+        if (!elemref) {
+            rstring = xml_doc->createTextNode(label_value.c_str());
+            rtspan->addChild(rstring, NULL);
+            Inkscape::GC::release(rstring);
+        } else {
+            rstring = rtspan->firstChild();
+            rstring->setContent(label_value.c_str());
+        }
+        if (!elemref) {
+            elemref = SP_OBJECT(desktop->currentLayer()->appendChildRepr(rtext));
+            Inkscape::GC::release(rtext);
+        }
+        Inkscape::XML::Node *tmp_node = rtext->duplicate(xml_doc);
+        affine = Geom::Affine(Geom::Scale(1.4));
+        tmp_node->setAttribute("transform", sp_svg_transform_write(affine));
+        SPObject * tmp_obj = SP_OBJECT(desktop->currentLayer()->appendChildRepr(tmp_node));
+        Inkscape::GC::release(tmp_node);
+        tmp_obj->updateRepr();
+        Geom::OptRect bounds = SP_ITEM(tmp_obj)->bounds(SPItem::GEOMETRIC_BBOX);
+        if (bounds) {
+            anotation_width = bounds->width();
+        }
+        tmp_obj->deleteObject();
+    }
+}
+
+void
+LPEMeasureLine::createLine(Geom::Point start,Geom::Point end, Glib::ustring id, bool main, bool overflow, bool remove, bool arrows)
+{
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + id).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        Inkscape::XML::Node *line = NULL;
+        if (!main) {
+            Geom::Ray ray(start, end);
+            Geom::Coord angle = ray.angle();
+            start = start + Point::polar(angle, helpline_distance );
+            end = end + Point::polar(angle, helpline_overlap );
+        }
+        Geom::PathVector line_pathv;
+        if (main && std::abs(text_top_bottom) < fontsize/1.5 && hide_back && !overflow){
+            Geom::Path line_path;
+            double k = 0;
+            if (flip_side) {
+                k = (Geom::distance(start,end)/2.0) + arrow_gap - (anotation_width/2.0);
+            } else {
+                k = (Geom::distance(start,end)/2.0) - arrow_gap - (anotation_width/2.0);
+            }
+            if (Geom::distance(start,end) < anotation_width){
+                return;
+            }
+            Geom::Ray ray(end, start);
+            Geom::Coord angle = ray.angle();
+            line_path.start(start);
+            line_path.appendNew<Geom::LineSegment>(start - Point::polar(angle, k));
+            line_pathv.push_back(line_path);
+            line_path.clear();
+            line_path.start(end + Point::polar(angle, k));
+            line_path.appendNew<Geom::LineSegment>(end);
+            line_pathv.push_back(line_path);
+        } else {
+            Geom::Path line_path;
+            line_path.start(start);
+            line_path.appendNew<Geom::LineSegment>(end);
+            line_pathv.push_back(line_path);
+        }
+        
+        if (elemref = SVGElemRef->getObject()) {
+            if (remove) {
+                elemref->deleteObject();
+                return;
+            }
+            line = elemref->getRepr();
+           
+            gchar * line_str = sp_svg_write_path( line_pathv );
+            line->setAttribute("d" , line_str);
+        } else {
+            if (remove) {
+                return;
+            }
+            line = xml_doc->createElement("svg:path");
+            line->setAttribute("id", id.c_str());
+            gchar * line_str = sp_svg_write_path( line_pathv );
+            line->setAttribute("d" , line_str);
+        }
+        line->setAttribute("sodipodi:insensitive", "true");
+        line_pathv.clear();
+        
+        Glib::ustring style = (Glib::ustring)"stroke:#000000;fill:none;";
+        if (overflow && !arrows) {
+            line->setAttribute("inkscape:label", "downline");
+        } else if (main) {
+            line->setAttribute("inkscape:label", "dinline");
+            if (arrows_outside) {
+                style = style + (Glib::ustring)"marker-start:url(#ArrowDINout-start);marker-end:url(#ArrowDINout-end);";
+            } else {
+                style = style + (Glib::ustring)"marker-start:url(#ArrowDIN-start);marker-end:url(#ArrowDIN-end);";
+            }
+        } else {
+            line->setAttribute("inkscape:label", "dinhelpline");
+        }
+        std::stringstream stroke_w;
+        stroke_w.imbue(std::locale::classic());
+        if (line_group_05) {
+            double stroke_width = Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
+            stroke_w <<  stroke_width;
+            style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
+        } else {
+            double stroke_width = Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
+            stroke_w <<  stroke_width;
+            style = style + (Glib::ustring)"stroke-width:" + (Glib::ustring)stroke_w.str();
+        }
+        SPCSSAttr *css = sp_repr_css_attr_new();
+        sp_repr_css_attr_add_from_string(css, style.c_str());
+        if (main) {
+            sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
+        } else {
+            sp_repr_css_attr_add_from_string(css, helperlines_format.param_getSVGValue());
+        }
+        Glib::ustring css_str;
+        sp_repr_css_write_string(css,css_str);
+        line->setAttribute("style", css_str.c_str());
+        if (!elemref) {
+            elemref = SP_OBJECT(desktop->currentLayer()->appendChildRepr(line));
+            Inkscape::GC::release(line);
+        }
+    }
+}
+
+void
+LPEMeasureLine::doBeforeEffect (SPLPEItem const* lpeitem)
+{
+    SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
+    SPPath *sp_path = dynamic_cast<SPPath *>(splpeitem);
+    if (sp_path) {
+        SPDocument * doc = SP_ACTIVE_DOCUMENT;
+        Geom::Affine affinetransform = i2anc_affine(SP_OBJECT(lpeitem)->parent, SP_OBJECT(doc->getRoot()));
+        double parents_scale = (affinetransform.inverse().expansionX() + affinetransform.inverse().expansionY()) / 2.0;
+        
+        Geom::PathVector pathvector = sp_path->get_original_curve()->get_pathvector();
+        pathvector *= affinetransform;
+        if (arrows_outside) {
+            createArrowMarker((Glib::ustring)"ArrowDINout-start");
+            createArrowMarker((Glib::ustring)"ArrowDINout-end");
+        } else {
+            createArrowMarker((Glib::ustring)"ArrowDIN-start");
+            createArrowMarker((Glib::ustring)"ArrowDIN-end");
+        }
+        if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+            if (((Glib::ustring)format.param_getSVGValue()).empty()) {
+                format.param_setValue((Glib::ustring)"{measure}{unit}");
+                this->upd_params = true;
+            }
+            size_t ncurves = pathvector.curveCount();
+            curve_linked.param_set_range(0, ncurves);
+            Geom::Point start = pathvector.initialPoint();
+            Geom::Point end =  pathvector.finalPoint();
+            if (curve_linked) { //!0 
+                start = pathvector.pointAt(curve_linked -1);
+                end = pathvector.pointAt(curve_linked);
+            }
+            Geom::Point hstart = start;
+            Geom::Point hend = end;
+            bool remove = false;
+            if (Geom::are_near(hstart, hend)) {
+                remove = true;
+            }
+            if (orientation == OM_VERTICAL) {
+                Coord xpos = std::max(hstart[Geom::X],hend[Geom::X]);
+                if (flip_side) {
+                    xpos = std::min(hstart[Geom::X],hend[Geom::X]);
+                }
+                hstart[Geom::X] = xpos;
+                hend[Geom::X] = xpos;
+                if (hstart[Geom::Y] > hend[Geom::Y]) {
+                    swap(hstart,hend);
+                    swap(start,end);
+                }
+                if (Geom::are_near(hstart[Geom::Y], hend[Geom::Y])) {
+                    remove = true;
+                }
+            }
+            if (orientation == OM_HORIZONTAL) {
+                Coord ypos = std::max(hstart[Geom::Y],hend[Geom::Y]);
+                if (flip_side) {
+                    ypos = std::min(hstart[Geom::Y],hend[Geom::Y]);
+                }
+                hstart[Geom::Y] = ypos;
+                hend[Geom::Y] = ypos;
+                if (hstart[Geom::X] < hend[Geom::X]) {
+                    swap(hstart,hend);
+                    swap(start,end);
+                }
+                if (Geom::are_near(hstart[Geom::X], hend[Geom::X])) {
+                    remove = true;
+                }
+            }
+            double length = Geom::distance(hstart,hend)  * scale;
+            Geom::Point pos = Geom::middle_point(hstart,hend);
+            Geom::Ray ray(hstart,hend);
+            Geom::Coord angle = ray.angle();
+            if (flip_side) {
+                angle = std::fmod(angle + rad_from_deg(180), 2*M_PI);
+                if (angle < 0) angle += 2*M_PI;
+            }
+            //We get the font size to offset the text to the middle
+            Pango::FontDescription fontdesc((Glib::ustring)fontbutton.param_getSVGValue());
+            fontsize = fontdesc.get_size()/(double)Pango::SCALE;
+            fontsize *= desktop->doc()->getRoot()->c2p.inverse().expansionX();
+            Geom::Coord angle_cross = std::fmod(angle + rad_from_deg(90), 2*M_PI);
+            if (angle_cross < 0) angle_cross += 2*M_PI;
+            angle = std::fmod(angle, 2*M_PI);
+            if (angle < 0) angle += 2*M_PI;
+            if (angle >= rad_from_deg(90) && angle < rad_from_deg(270)) {
+                pos = pos - Point::polar(angle_cross, (position - text_top_bottom) + fontsize/2.5);
+            } else {
+                pos = pos - Point::polar(angle_cross, (position + text_top_bottom) - fontsize/2.5);
+            }
+            if (scale_insensitive) {
+                length *= parents_scale;
+            }
+            createTextLabel(pos, length, angle, remove);
+            bool overflow = false;
+            if ((anotation_width/2) + std::abs(text_right_left) > Geom::distance(start,end)/2.0) {
+                Geom::Point sstart = end - Point::polar(angle_cross, position);
+                Geom::Point send = end - Point::polar(angle_cross, position);
+                if (text_right_left < 0 && flip_side || text_right_left > 0 && !flip_side) {
+                    sstart = start - Point::polar(angle_cross, position);
+                    send = start - Point::polar(angle_cross, position);
+                }
+                Geom::Point prog_end = Geom::Point();
+                if (std::abs(text_top_bottom) < fontsize/1.5 && hide_back) { 
+                    if (text_right_left > 0 ) {
+                        prog_end = sstart - Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
+                    } else {
+                        prog_end = sstart + Point::polar(angle, std::abs(text_right_left) - (anotation_width/1.9) - (Geom::distance(start,end)/2.0));
+                    }
+                } else {
+                    if (text_right_left > 0 ) {
+                        prog_end = sstart - Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
+                    } else {
+                        prog_end = sstart + Point::polar(angle,(anotation_width/2) + std::abs(text_right_left) - (Geom::distance(start,end)/2.0));
+                    }
+                }
+                overflow = true;
+                createLine(sstart, prog_end, (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), true, overflow, false, false);
+            } else {
+                //erase it
+                createLine(Geom::Point(),Geom::Point(), (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id"), true, overflow, true, false);
+            }
+            //LINE
+            arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.35 / doc_scale, "mm", display_unit.c_str());
+            if (line_group_05) {
+                arrow_gap = 8 * Inkscape::Util::Quantity::convert(0.25 / doc_scale, "mm", display_unit.c_str());
+            }
+            SPCSSAttr *css = sp_repr_css_attr_new();
+            sp_repr_css_attr_add_from_string(css, dimline_format.param_getSVGValue());
+            setlocale(LC_NUMERIC, std::locale::classic().name().c_str());
+            double width_line =  atof(sp_repr_css_property(css,"stroke-width","-1"));
+            setlocale(LC_NUMERIC, std::locale("").name().c_str());
+            if (width_line > -0.0001) {
+                 arrow_gap = 8 * Inkscape::Util::Quantity::convert(width_line/ doc_scale, "mm", display_unit.c_str());
+            }
+            if (flip_side) {
+                arrow_gap *= -1;
+            }
+            hstart = hstart - Point::polar(angle_cross, position);
+            Glib::ustring id = (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id");
+            createLine(start, hstart, id, false, false, remove);
+            hend = hend - Point::polar(angle_cross, position);
+            id = (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id");
+            createLine(end, hend, id, false, false, remove);
+            if (!arrows_outside) {
+                hstart = hstart + Point::polar(angle, arrow_gap);
+                hend = hend - Point::polar(angle, arrow_gap );
+            }
+            id = (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id");
+            createLine(hstart, hend, id, true, overflow, remove, true);
+        }
+    }
+}
+
+void LPEMeasureLine::doOnRemove (SPLPEItem const* lpeitem)
+{
+    if (!erase) return;
+    
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->deleteObject();
+        }
+        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri2);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->deleteObject();
+        }
+        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri3);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->deleteObject();
+        }
+        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri4);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->deleteObject();
+        }
+        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri5);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->deleteObject();
+        }
+    }
+}
+
+void LPEMeasureLine::toObjects()
+{
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) {
+        
+        Inkscape::URI SVGElem_uri(((Glib::ustring)"#" + (Glib::ustring)"text-on-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        Inkscape::URIReference* SVGElemRef = new Inkscape::URIReference(desktop->doc());
+        SVGElemRef->attach(SVGElem_uri);
+        SPObject *elemref = NULL;
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+        }
+        Inkscape::URI SVGElem_uri2(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-end-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri2);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+        }
+        Inkscape::URI SVGElem_uri3(((Glib::ustring)"#" + (Glib::ustring)"infoline-on-start-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri3);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+        }
+        Inkscape::URI SVGElem_uri4(((Glib::ustring)"#" + (Glib::ustring)"infoline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri4);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+        }
+        Inkscape::URI SVGElem_uri5(((Glib::ustring)"#" + (Glib::ustring)"downline-" + (Glib::ustring)this->getRepr()->attribute("id")).c_str());
+        SVGElemRef->attach(SVGElem_uri5);
+        if (elemref = SVGElemRef->getObject()) {
+            elemref->getRepr()->setAttribute("sodipodi:insensitive", NULL);
+        }
+        erase = false;
+        sp_lpe_item->removeCurrentPathEffect(true);
+        //TODO: find better way to refresh effect list
+        if (SP_IS_OBJECT(sp_lpe_item)){
+            Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
+            selection->remove(SP_OBJECT(sp_lpe_item));
+            selection->add(SP_OBJECT(sp_lpe_item));
+        }
+    }
+}
+
+Gtk::Widget *LPEMeasureLine::newWidget()
+{
+    // use manage here, because after deletion of Effect object, others might
+    // still be pointing to this widget.
+    Gtk::VBox *vbox = Gtk::manage(new Gtk::VBox(Effect::newWidget()));
+
+    vbox->set_border_width(5);
+    vbox->set_homogeneous(false);
+    vbox->set_spacing(2);
+
+    std::vector<Parameter *>::iterator it = param_vector.begin();
+    Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0));
+    Gtk::HBox * button2 = Gtk::manage(new Gtk::HBox(true,0));
+    Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) );
+    vbox_expander->set_border_width(0);
+    vbox_expander->set_spacing(2);
+    while (it != param_vector.end()) {
+        if ((*it)->widget_is_visible) {
+            Parameter *param = *it;
+            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
+            Glib::ustring *tip = param->param_getTooltip();
+            if (widg) {
+                if (param->param_key != "dimline_format" &&
+                    param->param_key != "helperlines_format" &&
+                    param->param_key != "arrows_format" &&
+                    param->param_key != "anotation_format") {
+                    vbox->pack_start(*widg, true, true, 2);
+                } else {
+                    vbox_expander->pack_start(*widg, true, true, 2);
+                }
+                if (tip) {
+                    widg->set_tooltip_text(*tip);
+                } else {
+                    widg->set_tooltip_text("");
+                    widg->set_has_tooltip(false);
+                }
+            }
+        }
+
+        ++it;
+    }
+    Gtk::Button *save_default = Gtk::manage(new Gtk::Button(Glib::ustring(_("Save '*' as default"))));
+    save_default->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::saveDefault));
+    button1->pack_start(*save_default, true, true, 2);
+    Gtk::Button *remove = Gtk::manage(new Gtk::Button(Glib::ustring(_("Convert to objects"))));
+    remove->signal_clicked().connect(sigc::mem_fun(*this, &LPEMeasureLine::toObjects));
+    button2->pack_start(*remove, true, true, 2);
+    expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show DIM CSS style override"))));
+    expander->add(*vbox_expander);
+    expander->set_expanded(expanded);
+    expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPEMeasureLine::onExpanderChanged) );
+    vbox->pack_start(*expander, true, true, 2);
+    vbox->pack_start(*button1, true, true, 2);
+    vbox->pack_start(*button2, true, true, 2);
+    return dynamic_cast<Gtk::Widget *>(vbox);
+}
+
+void
+LPEMeasureLine::onExpanderChanged()
+{
+    expanded = expander->get_expanded();
+    if(expanded) {
+        expander->set_label (Glib::ustring(_("Hide DIM CSS style override")));
+    } else {
+        expander->set_label (Glib::ustring(_("Show DIM CSS style override")));
+    }
+}
+
+Geom::PathVector
+LPEMeasureLine::doEffect_path(Geom::PathVector const &path_in)
+{
+    return path_in;
+}
+
+void
+LPEMeasureLine::saveDefault()
+{
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    prefs->setString("/live_effects/measure-line/fontbutton", (Glib::ustring)fontbutton.param_getSVGValue());
+    prefs->setDouble("/live_effects/measure-line/scale", scale);
+    prefs->setInt("/live_effects/measure-line/precision", precision);
+    prefs->setDouble("/live_effects/measure-line/position", position);
+    prefs->setDouble("/live_effects/measure-line/text_top_bottom", text_top_bottom);
+    prefs->setDouble("/live_effects/measure-line/helpline_distance", helpline_distance);
+    prefs->setDouble("/live_effects/measure-line/helpline_overlap", helpline_overlap);
+    prefs->setString("/live_effects/measure-line/unit", (Glib::ustring)unit.get_abbreviation());
+    prefs->setString("/live_effects/measure-line/format", (Glib::ustring)format.param_getSVGValue());
+    prefs->setString("/live_effects/measure-line/dimline_format", (Glib::ustring)dimline_format.param_getSVGValue());
+    prefs->setString("/live_effects/measure-line/helperlines_format", (Glib::ustring)helperlines_format.param_getSVGValue());
+    prefs->setString("/live_effects/measure-line/anotation_format", (Glib::ustring)anotation_format.param_getSVGValue());
+    prefs->setString("/live_effects/measure-line/arrows_format", (Glib::ustring)arrows_format.param_getSVGValue());
+    prefs->setBool("/live_effects/measure-line/flip_side", flip_side);
+    prefs->setBool("/live_effects/measure-line/scale_insensitive", scale_insensitive);
+    prefs->setBool("/live_effects/measure-line/local_locale", local_locale);
+    prefs->setBool("/live_effects/measure-line/line_group_05", line_group_05);
+    prefs->setBool("/live_effects/measure-line/rotate_anotation", rotate_anotation);
+    prefs->setBool("/live_effects/measure-line/hide_back", hide_back);
+}
+
+}; //namespace LivePathEffect
+}; /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offset:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/lpe-measure-line.h b/src/live_effects/lpe-measure-line.h
new file mode 100644
index 000000000..2fab9dbb9
--- /dev/null
+++ b/src/live_effects/lpe-measure-line.h
@@ -0,0 +1,103 @@
+#ifndef INKSCAPE_LPE_MEASURE_LINE_H
+#define INKSCAPE_LPE_MEASURE_LINE_H
+
+/*
+ * Author(s):
+ *     Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2014 Author(s)
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+#include "live_effects/effect.h"
+#include "live_effects/parameter/enum.h"
+#include "live_effects/parameter/fontbutton.h"
+#include "live_effects/parameter/text.h"
+#include "live_effects/parameter/unit.h"
+#include "live_effects/parameter/bool.h"
+#include "live_effects/parameter/originalpath.h"
+#include <libnrtype/font-lister.h>
+#include <2geom/angle.h>
+#include <2geom/ray.h>
+#include <2geom/point.h>
+
+namespace Inkscape {
+namespace LivePathEffect {
+
+enum OrientationMethod {
+    OM_HORIZONTAL,
+    OM_VERTICAL,
+    OM_PARALLEL,
+    OM_END
+};
+
+class LPEMeasureLine : public Effect {
+public:
+    LPEMeasureLine(LivePathEffectObject *lpeobject);
+    virtual ~LPEMeasureLine();
+    virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+    virtual void doOnApply(SPLPEItem const* lpeitem);
+    virtual void doOnRemove (SPLPEItem const* lpeitem);
+    virtual void doOnVisibilityToggled(SPLPEItem const* /*lpeitem*/);
+    virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
+    void createLine(Geom::Point start,Geom::Point end,Glib::ustring id, bool main, bool overflow, bool remove, bool arrows = false);
+    void createTextLabel(Geom::Point pos, double length, Geom::Coord angle, bool remove);
+    void onExpanderChanged();
+    void toObjects();
+    void createArrowMarker(Glib::ustring mode);
+    void saveDefault();
+    virtual Gtk::Widget *newWidget();
+private:
+    UnitParam unit;
+    FontButtonParam fontbutton;
+    EnumParam<OrientationMethod> orientation;
+    ScalarParam curve_linked;
+    ScalarParam precision;
+    ScalarParam position;
+    ScalarParam text_top_bottom;
+    ScalarParam text_right_left;
+    ScalarParam helpline_distance;
+    ScalarParam helpline_overlap;
+    ScalarParam scale;
+    TextParam format;
+    BoolParam arrows_outside;
+    BoolParam flip_side;
+    BoolParam scale_insensitive;
+    BoolParam local_locale;
+    BoolParam line_group_05;
+    BoolParam rotate_anotation;
+    BoolParam hide_back;
+    TextParam dimline_format;
+    TextParam helperlines_format;
+    TextParam anotation_format;
+    TextParam arrows_format;
+    Glib::ustring display_unit;
+    bool expanded;
+    Gtk::Expander * expander;
+    double doc_scale;
+    double fontsize;
+    double anotation_width;
+    double arrow_gap;
+    bool erase;
+/*    Geom::Affine affine_over;*/
+    LPEMeasureLine(const LPEMeasureLine &);
+    LPEMeasureLine &operator=(const LPEMeasureLine &);
+
+};
+
+} //namespace LivePathEffect
+} //namespace Inkscape
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp
index 2b03a4bb2..78db622f2 100644
--- a/src/live_effects/lpe-transform_2pts.cpp
+++ b/src/live_effects/lpe-transform_2pts.cpp
@@ -87,7 +87,6 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem)
 {
     using namespace Geom;
     original_bbox(lpeitem);
-
     point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
     point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
     SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
diff --git a/src/live_effects/lpeobject.h b/src/live_effects/lpeobject.h
index 2e62707e3..087223947 100644
--- a/src/live_effects/lpeobject.h
+++ b/src/live_effects/lpeobject.h
@@ -38,8 +38,14 @@ public:
 
     /* Note that the returned pointer can be NULL in a valid LivePathEffectObject contained in a valid list of lpeobjects in an lpeitem!
      * So one should always check whether the returned value is NULL or not */
-    Inkscape::LivePathEffect::Effect * get_lpe() { return lpe; };
-    Inkscape::LivePathEffect::Effect const * get_lpe() const { return lpe; };
+    Inkscape::LivePathEffect::Effect * get_lpe() {
+        if(this) return lpe;
+        else return NULL;
+    }
+    Inkscape::LivePathEffect::Effect const * get_lpe() const {
+        if(this) return lpe;
+        else return NULL;
+    };
 
     Inkscape::LivePathEffect::Effect *lpe; // this can be NULL in a valid LivePathEffectObject
 
diff --git a/src/live_effects/parameter/bool.cpp b/src/live_effects/parameter/bool.cpp
index 9ecadbdeb..af99ef362 100644
--- a/src/live_effects/parameter/bool.cpp
+++ b/src/live_effects/parameter/bool.cpp
@@ -36,6 +36,12 @@ BoolParam::param_set_default()
     param_setValue(defvalue);
 }
 
+void 
+BoolParam::param_update_default(bool const default_value)
+{
+    defvalue = default_value;
+}
+
 bool
 BoolParam::param_readSVGValue(const gchar * strvalue)
 {
diff --git a/src/live_effects/parameter/bool.h b/src/live_effects/parameter/bool.h
index 403dd0b87..7ad8a9368 100644
--- a/src/live_effects/parameter/bool.h
+++ b/src/live_effects/parameter/bool.h
@@ -36,7 +36,7 @@ public:
 
     void param_setValue(bool newvalue);
     virtual void param_set_default();
-
+    void param_update_default(bool const default_value);
     bool get_value() const { return value; };
 
     inline operator bool() const { return value; };
diff --git a/src/live_effects/parameter/enum.h b/src/live_effects/parameter/enum.h
index 2340663c3..dbfc68623 100644
--- a/src/live_effects/parameter/enum.h
+++ b/src/live_effects/parameter/enum.h
@@ -27,12 +27,14 @@ public:
                 const Util::EnumDataConverter<E>& c,
                 Inkscape::UI::Widget::Registry* wr,
                 Effect* effect,
-                E default_value)
+                E default_value,
+                bool sort = true)
         : Parameter(label, tip, key, wr, effect)
     {
         enumdataconv = &c;
         defvalue = default_value;
         value = defvalue;
+        sorted = sort;
     };
 
     virtual ~EnumParam() { };
@@ -40,12 +42,11 @@ public:
     virtual Gtk::Widget * param_newWidget() {
         Inkscape::UI::Widget::RegisteredEnum<E> *regenum = Gtk::manage ( 
             new Inkscape::UI::Widget::RegisteredEnum<E>( param_label, param_tooltip,
-                       param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc() ) );
+                       param_key, *enumdataconv, *param_wr, param_effect->getRepr(), param_effect->getSPDoc(), sorted ) );
 
         regenum->set_active_by_id(value);
         regenum->combobox()->setProgrammatically = false;
         regenum->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change enumeration parameter"));
-
         return dynamic_cast<Gtk::Widget *> (regenum);
     };
 
@@ -86,6 +87,7 @@ private:
 
     E value;
     E defvalue;
+    bool sorted;
 
     const Util::EnumDataConverter<E> * enumdataconv;
 };
diff --git a/src/live_effects/parameter/fontbutton.cpp b/src/live_effects/parameter/fontbutton.cpp
new file mode 100644
index 000000000..ff8ab76a0
--- /dev/null
+++ b/src/live_effects/parameter/fontbutton.cpp
@@ -0,0 +1,92 @@
+/*
+ * Authors:
+ *
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+
+
+#include "ui/widget/registered-widget.h"
+#include "live_effects/parameter/fontbutton.h"
+#include "live_effects/effect.h"
+#include "ui/widget/font-button.h"
+#include "svg/svg.h"
+#include "svg/stringstream.h"
+#include "verbs.h"
+
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+FontButtonParam::FontButtonParam( const Glib::ustring& label, const Glib::ustring& tip,
+                      const Glib::ustring& key, Inkscape::UI::Widget::Registry* wr,
+                      Effect* effect, const Glib::ustring default_value )
+    : Parameter(label, tip, key, wr, effect),
+      value(default_value),
+      defvalue(default_value)
+{
+}
+
+void
+FontButtonParam::param_set_default()
+{
+    param_setValue(defvalue);
+}
+void 
+FontButtonParam::param_update_default(const Glib::ustring default_value){
+    defvalue = default_value;
+}
+
+bool
+FontButtonParam::param_readSVGValue(const gchar * strvalue)
+{
+    Inkscape::SVGOStringStream os;
+    os << strvalue;
+    param_setValue((Glib::ustring)os.str());
+    return true;
+}
+
+gchar *
+FontButtonParam::param_getSVGValue() const
+{
+    return g_strdup(value.c_str());
+}
+
+Gtk::Widget *
+FontButtonParam::param_newWidget()
+{
+    Inkscape::UI::Widget::RegisteredFontButton * fontbuttonwdg = Gtk::manage(
+        new Inkscape::UI::Widget::RegisteredFontButton( param_label,
+                                                        param_tooltip,
+                                                        param_key,
+                                                        *param_wr,
+                                                        param_effect->getRepr(),
+                                                        param_effect->getSPDoc() ) );
+    Glib::ustring fontspec = param_getSVGValue();
+    fontbuttonwdg->setValue( fontspec);
+    fontbuttonwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change font button parameter"));
+    param_effect->upd_params = false;
+    return dynamic_cast<Gtk::Widget *> (fontbuttonwdg);
+}
+
+void
+FontButtonParam::param_setValue(const Glib::ustring newvalue)
+{
+    value = newvalue;
+}
+
+} /* namespace LivePathEffect */
+
+} /* namespace Inkscape */
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/parameter/fontbutton.h b/src/live_effects/parameter/fontbutton.h
new file mode 100644
index 000000000..387ad130b
--- /dev/null
+++ b/src/live_effects/parameter/fontbutton.h
@@ -0,0 +1,62 @@
+#ifndef INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
+#define INKSCAPE_LIVEPATHEFFECT_PARAMETER_FONT_H
+
+/*
+ * Inkscape::LivePathEffectParameters
+ *
+ * Authors:
+ * Released under GNU GPL, read the file 'COPYING' for more information
+ */
+#include <glib.h>
+#include <gtkmm.h>
+#include "live_effects/parameter/parameter.h"
+
+namespace Inkscape {
+
+namespace LivePathEffect {
+
+class FontButtonParam : public Parameter {
+public:
+    FontButtonParam( const Glib::ustring& label,
+               const Glib::ustring& tip,
+               const Glib::ustring& key,
+               Inkscape::UI::Widget::Registry* wr,
+               Effect* effect,
+               const Glib::ustring default_value = "");
+    virtual ~FontButtonParam() {}
+
+    virtual Gtk::Widget * param_newWidget();
+    virtual bool param_readSVGValue(const gchar * strvalue);
+    void param_update_default(const Glib::ustring defvalue);
+    virtual gchar * param_getSVGValue() const;
+
+    void param_setValue(const Glib::ustring newvalue);
+    
+    virtual void param_set_default();
+
+    const Glib::ustring get_value() const { return defvalue; };
+
+private:
+    FontButtonParam(const FontButtonParam&);
+    FontButtonParam& operator=(const FontButtonParam&);
+    Glib::ustring value;
+    Glib::ustring defvalue;
+
+};
+
+} //namespace LivePathEffect
+
+} //namespace Inkscape
+
+#endif
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index d4e213948..befac4df1 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -4,11 +4,9 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "ui/widget/registered-widget.h"
-#include <glibmm/i18n.h>
 
-#include "live_effects/parameter/parameter.h"
 #include "live_effects/effect.h"
+#include "live_effects/parameter/parameter.h"
 #include "svg/svg.h"
 #include "xml/repr.h"
 
@@ -16,6 +14,8 @@
 
 #include "verbs.h"
 
+#include <glibmm/i18n.h>
+
 #define noLPEREALPARAM_DEBUG
 
 namespace Inkscape {
@@ -101,9 +101,16 @@ ScalarParam::param_set_default()
     param_set_value(defvalue);
 }
 
+void 
+ScalarParam::param_update_default(gdouble default_value)
+{
+    defvalue = default_value;
+}
+
 void
 ScalarParam::param_set_value(gdouble val)
 {
+    param_effect->upd_params = true;
     value = val;
     if (integer)
         value = round(value);
@@ -121,7 +128,7 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     // Once again, in gtk2, this is not a problem. But in gtk3,
     // widgets get allocated the amount of size they ask for,
     // leading to excessively long widgets.
-
+    param_effect->upd_params = true;
     if (min >= -SCALARPARAM_G_MAXDOUBLE) {
         this->min = min;
     } else {
@@ -130,15 +137,15 @@ ScalarParam::param_set_range(gdouble min, gdouble max)
     if (max <= SCALARPARAM_G_MAXDOUBLE) {
         this->max = max;
     } else {
-	this->max = SCALARPARAM_G_MAXDOUBLE;
+        this->max = SCALARPARAM_G_MAXDOUBLE;
     }
-
     param_set_value(value); // reset value to see whether it is in ranges
 }
 
 void
 ScalarParam::param_make_integer(bool yes)
 {
+    param_effect->upd_params = true;
     integer = yes;
     digits = 0;
     inc_step = 1;
@@ -169,6 +176,7 @@ ScalarParam::param_newWidget()
         if(!overwrite_widget){
             rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
         }
+        param_effect->upd_params = false;
         return dynamic_cast<Gtk::Widget *> (rsu);
     } else {
         return NULL;
@@ -178,12 +186,14 @@ ScalarParam::param_newWidget()
 void
 ScalarParam::param_set_digits(unsigned digits)
 {
+    param_effect->upd_params = true;
     this->digits = digits;
 }
 
 void
 ScalarParam::param_set_increments(double step, double page)
 {
+    param_effect->upd_params = true;
     inc_step = step;
     inc_page = page;
 }
diff --git a/src/live_effects/parameter/parameter.h b/src/live_effects/parameter/parameter.h
index 0ef28650a..3658bded8 100644
--- a/src/live_effects/parameter/parameter.h
+++ b/src/live_effects/parameter/parameter.h
@@ -12,6 +12,7 @@
 #include <glibmm/ustring.h>
 #include <2geom/forward.h>
 #include <2geom/pathvector.h>
+#include "ui/widget/registered-widget.h"
 
 // In gtk2, this wasn't an issue; we could toss around
 // G_MAXDOUBLE and not worry about size allocations. But
@@ -110,12 +111,12 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     virtual void param_set_default();
+    void param_update_default(gdouble default_value);
     void param_set_value(gdouble val);
     void param_make_integer(bool yes = true);
     void param_set_range(gdouble min, gdouble max);
     void param_set_digits(unsigned digits);
     void param_set_increments(double step, double page);
-
     void addSlider(bool add_slider_widget) { add_slider = add_slider_widget; };
 
     void param_overwrite_widget(bool overwrite_widget);
diff --git a/src/live_effects/parameter/point.cpp b/src/live_effects/parameter/point.cpp
index ca3471b29..3442fd851 100644
--- a/src/live_effects/parameter/point.cpp
+++ b/src/live_effects/parameter/point.cpp
@@ -4,7 +4,6 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include "ui/widget/registered-widget.h"
 #include "live_effects/parameter/point.h"
 #include "live_effects/effect.h"
 #include "svg/svg.h"
@@ -30,7 +29,8 @@ PointParam::PointParam( const Glib::ustring& label, const Glib::ustring& tip,
     :   Parameter(label, tip, key, wr, effect), 
         defvalue(default_value),
         liveupdate(live_update),
-        knoth(NULL)
+        knoth(NULL),
+        _pointwdg(NULL)
 {
     knot_shape = SP_KNOT_SHAPE_DIAMOND;
     knot_mode  = SP_KNOT_MODE_XOR;
@@ -62,9 +62,9 @@ PointParam::param_get_default() const{
 }
 
 void
-PointParam::param_update_default(Geom::Point newpoint)
+PointParam::param_update_default(const Geom::Point default_point)
 {
-    defvalue = newpoint;
+    defvalue = default_point;
 }
 
 void
@@ -81,6 +81,9 @@ PointParam::param_setValue(Geom::Point newpoint, bool write)
     if(knoth && liveupdate){
         knoth->update_knots();
     }
+    if (_pointwdg) {
+        _pointwdg->setValue( newpoint );
+    }
 }
 
 bool
@@ -116,7 +119,7 @@ PointParam::param_transform_multiply(Geom::Affine const& postmul, bool /*set*/)
 Gtk::Widget *
 PointParam::param_newWidget()
 {
-    Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg = Gtk::manage(
+    _pointwdg = Gtk::manage(
         new Inkscape::UI::Widget::RegisteredTransformedPoint( param_label,
                                                               param_tooltip,
                                                               param_key,
@@ -126,15 +129,15 @@ PointParam::param_newWidget()
     // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     Geom::Affine transf = desktop->doc2dt();
-    pointwdg->setTransform(transf);
-    pointwdg->setValue( *this );
-    pointwdg->clearProgrammatically();
-    pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
+    _pointwdg->setTransform(transf);
+    _pointwdg->setValue( *this );
+    _pointwdg->clearProgrammatically();
+    _pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change point parameter"));
 
     Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
-    static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
+    static_cast<Gtk::HBox*>(hbox)->pack_start(*_pointwdg, true, true);
     static_cast<Gtk::HBox*>(hbox)->show_all_children();
-
+    param_effect->upd_params = false;
     return dynamic_cast<Gtk::Widget *> (hbox);
 }
 
@@ -191,13 +194,13 @@ void
 PointParamKnotHolderEntity::knot_click(guint state)
 {
     if (state & GDK_CONTROL_MASK) {
-            if (state & GDK_MOD1_MASK) {
-                this->pparam->param_set_default();
-                SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
-                if(splpeitem){
-                    sp_lpe_item_update_patheffect(splpeitem, false, false);
-                }
+        if (state & GDK_MOD1_MASK) {
+            this->pparam->param_set_default();
+            SPLPEItem * splpeitem = dynamic_cast<SPLPEItem *>(item);
+            if(splpeitem){
+                sp_lpe_item_update_patheffect(splpeitem, false, false);
             }
+        }
     }
 }
 
diff --git a/src/live_effects/parameter/point.h b/src/live_effects/parameter/point.h
index 4329e0bcd..62c6fb83d 100644
--- a/src/live_effects/parameter/point.h
+++ b/src/live_effects/parameter/point.h
@@ -11,7 +11,7 @@
 
 #include <glib.h>
 #include <2geom/point.h>
-
+#include "ui/widget/registered-widget.h"
 #include "live_effects/parameter/parameter.h"
 
 #include "knot-holder-entity.h"
@@ -43,7 +43,7 @@ public:
     void param_set_default();
     Geom::Point param_get_default() const;
     void param_set_liveupdate(bool live_update);
-    void param_update_default(Geom::Point newpoint);
+    void param_update_default(const Geom::Point default_point);
     virtual void param_transform_multiply(Geom::Affine const& /*postmul*/, bool /*set*/);
 
     void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
@@ -62,6 +62,7 @@ private:
     SPKnotModeType knot_mode;
     guint32 knot_color;
     gchar *handle_tip;
+    Inkscape::UI::Widget::RegisteredTransformedPoint * _pointwdg;
 };
 
 
diff --git a/src/live_effects/parameter/text.cpp b/src/live_effects/parameter/text.cpp
index 234a6174d..0650b7e66 100644
--- a/src/live_effects/parameter/text.cpp
+++ b/src/live_effects/parameter/text.cpp
@@ -31,12 +31,16 @@ TextParam::TextParam( const Glib::ustring& label, const Glib::ustring& tip,
                       Effect* effect, const Glib::ustring default_value )
     : Parameter(label, tip, key, wr, effect),
       value(default_value),
-      defvalue(default_value)
+      defvalue(default_value),
+      _hide_canvas_text(false)
 {
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP; // FIXME: we shouldn't use this!
-    canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
-    sp_canvastext_set_text (canvas_text, default_value.c_str());
-    sp_canvastext_set_coords (canvas_text, 0, 0);
+    if (SPDesktop *desktop = SP_ACTIVE_DESKTOP) { // FIXME: we shouldn't use this!
+        canvas_text = (SPCanvasText *) sp_canvastext_new(desktop->getTempGroup(), desktop, Geom::Point(0,0), "");
+        sp_canvastext_set_text (canvas_text, default_value.c_str());
+        sp_canvastext_set_coords (canvas_text, 0, 0);
+    } else {
+        _hide_canvas_text = true;
+    }
 }
 
 void
@@ -46,9 +50,26 @@ TextParam::param_set_default()
 }
 
 void
+TextParam::param_update_default(Glib::ustring default_value)
+{
+    defvalue = default_value;
+}
+
+void
+TextParam::param_hide_canvas_text()
+{
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_text(canvas_text, " ");
+        _hide_canvas_text = true;
+    }
+}
+
+void
 TextParam::setPos(Geom::Point pos)
 {
-    sp_canvastext_set_coords (canvas_text, pos);
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_coords (canvas_text, pos);
+    }
 }
 
 void
@@ -63,9 +84,10 @@ TextParam::setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
     Point dir = unit_vector(derivative(pwd2_reparam).valueAt(t_reparam));
     Point n = -rot90(dir);
     double angle = Geom::angle_between(dir, Point(1,0));
-
-    sp_canvastext_set_coords(canvas_text, pos + n * length);
-    sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_coords(canvas_text, pos + n * length);
+        sp_canvastext_set_anchor_manually(canvas_text, std::sin(angle), -std::cos(angle));
+    }
 }
 
 void
@@ -73,7 +95,9 @@ TextParam::setAnchor(double x_value, double y_value)
 {
     anchor_x = x_value;
     anchor_y = y_value;
-    sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_anchor_manually (canvas_text, anchor_x, anchor_y);
+    }
 }
 
 bool
@@ -94,8 +118,7 @@ TextParam::param_newWidget()
 {
     Inkscape::UI::Widget::RegisteredText *rsu = Gtk::manage(new Inkscape::UI::Widget::RegisteredText(
         param_label, param_tooltip, param_key, *param_wr, param_effect->getRepr(), param_effect->getSPDoc()));
-
-    rsu->setText(value.c_str());
+    rsu->setText(value);
     rsu->setProgrammatically = false;
 
     rsu->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change text parameter"));
@@ -107,8 +130,9 @@ void
 TextParam::param_setValue(const Glib::ustring newvalue)
 {
     value = newvalue;
-
-    sp_canvastext_set_text (canvas_text, newvalue.c_str());
+    if (!_hide_canvas_text) {
+        sp_canvastext_set_text (canvas_text, newvalue.c_str());
+    }
 }
 
 } /* namespace LivePathEffect */
diff --git a/src/live_effects/parameter/text.h b/src/live_effects/parameter/text.h
index 62de70eec..553c84c0a 100644
--- a/src/live_effects/parameter/text.h
+++ b/src/live_effects/parameter/text.h
@@ -40,7 +40,9 @@ public:
     virtual gchar * param_getSVGValue() const;
 
     void param_setValue(const Glib::ustring newvalue);
+    void param_hide_canvas_text();
     virtual void param_set_default();
+    void param_update_default(Glib::ustring default_value);
     void setPos(Geom::Point pos);
     void setPosAndAnchor(const Geom::Piecewise<Geom::D2<Geom::SBasis> > &pwd2,
 			 const double t, const double length, bool use_curvature = false);
@@ -53,7 +55,7 @@ private:
     TextParam& operator=(const TextParam&);
     double anchor_x;
     double anchor_y;
-
+    bool _hide_canvas_text;
     Glib::ustring value;
     Glib::ustring defvalue;
 
diff --git a/src/live_effects/parameter/togglebutton.cpp b/src/live_effects/parameter/togglebutton.cpp
index 023bebc03..b3f6442bb 100644
--- a/src/live_effects/parameter/togglebutton.cpp
+++ b/src/live_effects/parameter/togglebutton.cpp
@@ -12,6 +12,7 @@
 #include "live_effects/effect.h"
 #include "svg/svg.h"
 #include "svg/stringstream.h"
+#include "selection.h"
 #include "widgets/icon.h"
 #include "inkscape.h"
 #include "verbs.h"
@@ -104,13 +105,14 @@ ToggleButtonParam::param_newWidget()
     }else{
         gtk_box_pack_start (GTK_BOX(box_button), label_button, false, false, 1);
     }
+
     checkwdg->add(*Gtk::manage(Glib::wrap(box_button)));
     checkwdg->setActive(value);
     checkwdg->setProgrammatically = false;
     checkwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change togglebutton parameter"));
 
     _toggled_connection = checkwdg->signal_toggled().connect(sigc::mem_fun(*this, &ToggleButtonParam::toggled));
-
+    param_effect->upd_params = false;
     return checkwdg;
 }
 
@@ -157,6 +159,12 @@ ToggleButtonParam::param_setValue(bool newvalue)
 
 void
 ToggleButtonParam::toggled() {
+    //Force redraw for update widgets
+    param_effect->upd_params = true;
+    if (SP_ACTIVE_DESKTOP) {
+        Inkscape::Selection *selection = SP_ACTIVE_DESKTOP->getSelection();
+        selection->emitModified();
+    }
     _signal_toggled.emit();
 }
 
diff --git a/src/live_effects/parameter/unit.cpp b/src/live_effects/parameter/unit.cpp
index 0ee553e2c..b6ea99bfe 100644
--- a/src/live_effects/parameter/unit.cpp
+++ b/src/live_effects/parameter/unit.cpp
@@ -54,6 +54,12 @@ UnitParam::param_set_default()
     param_set_value(*defunit);
 }
 
+void 
+UnitParam::param_update_default(const Glib::ustring default_unit)
+{
+    defunit = unit_table.getUnit(default_unit);
+}
+
 void
 UnitParam::param_set_value(Inkscape::Util::Unit const &val)
 {
diff --git a/src/live_effects/parameter/unit.h b/src/live_effects/parameter/unit.h
index 59a483018..ae58cf956 100644
--- a/src/live_effects/parameter/unit.h
+++ b/src/live_effects/parameter/unit.h
@@ -33,6 +33,7 @@ public:
     virtual gchar * param_getSVGValue() const;
     virtual void param_set_default();
     void param_set_value(Inkscape::Util::Unit const &val);
+    void param_update_default(const Glib::ustring default_unit);
     const gchar *get_abbreviation() const;
 
     virtual Gtk::Widget * param_newWidget();
diff --git a/src/selection.h b/src/selection.h
index 4ea70c38d..cf00ba1f4 100644
--- a/src/selection.h
+++ b/src/selection.h
@@ -134,6 +134,7 @@ public:
      */
     void setReprList(std::vector<XML::Node*> const &reprs);
 
+
     using ObjectSet::includes;
 
     /**
@@ -166,6 +167,7 @@ public:
      *
      * @return the resulting connection
      */
+    void emitModified(){ _emitModified(this->_flags); };
     sigc::connection connectChanged(sigc::slot<void, Selection *> const &slot) {
         return _changed_signal.connect(slot);
     }
diff --git a/src/sp-item.cpp b/src/sp-item.cpp
index d161562fd..f52784489 100644
--- a/src/sp-item.cpp
+++ b/src/sp-item.cpp
@@ -76,7 +76,6 @@ SPItem::SPItem() : SPObject() {
     transform_center_y = 0;
 
     freeze_stroke_width = false;
-
     _is_evaluated = true;
     _evaluated_status = StatusUnknown;
 
@@ -1409,7 +1408,6 @@ Geom::Affine SPItem::set_transform(Geom::Affine const &transform) {
 void SPItem::doWriteTransform(Inkscape::XML::Node *repr, Geom::Affine const &transform, Geom::Affine const *adv, bool compensate)
 {
     g_return_if_fail(repr != NULL);
-
     // calculate the relative transform, if not given by the adv attribute
     Geom::Affine advertized_transform;
     if (adv != NULL) {
diff --git a/src/sp-lpe-item.cpp b/src/sp-lpe-item.cpp
index d83593b31..936594679 100644
--- a/src/sp-lpe-item.cpp
+++ b/src/sp-lpe-item.cpp
@@ -73,6 +73,7 @@ void SPLPEItem::build(SPDocument *document, Inkscape::XML::Node *repr) {
 
 void SPLPEItem::release() {
     // disconnect all modified listeners:
+    
     for (std::list<sigc::connection>::iterator mod_it = this->lpe_modified_connection_list->begin();
          mod_it != this->lpe_modified_connection_list->end(); ++mod_it)
     {
@@ -83,7 +84,7 @@ void SPLPEItem::release() {
     this->lpe_modified_connection_list = NULL;
 
     PathEffectList::iterator it = this->path_effect_list->begin();
-
+    
     while ( it != this->path_effect_list->end() ) {
         // unlink and delete all references in the list
         (*it)->unlink();
@@ -121,8 +122,10 @@ void SPLPEItem::set(unsigned int key, gchar const* value) {
 
                 while ( it != this->path_effect_list->end() )
                 {
+                    LivePathEffectObject *lpeobj = (*it)->lpeobject;
+                    lpeobj->get_lpe()->doOnRemove(this);
                     (*it)->unlink();
-                    delete *it;
+                    delete (*it);
                     it = this->path_effect_list->erase(it);
                 }
 
diff --git a/src/sp-object.cpp b/src/sp-object.cpp
index da4367d5b..cbd7aa969 100644
--- a/src/sp-object.cpp
+++ b/src/sp-object.cpp
@@ -485,13 +485,16 @@ void SPObject::_sendDeleteSignalRecursive() {
 void SPObject::deleteObject(bool propagate, bool propagate_descendants)
 {
     sp_object_ref(this, NULL);
+    if ( SP_IS_LPE_ITEM(this) ) {
+        SP_LPE_ITEM(this)->removeAllPathEffects(false);
+    }
     if (propagate) {
         _delete_signal.emit(this);
     }
     if (propagate_descendants) {
         this->_sendDeleteSignalRecursive();
     }
-
+    
     Inkscape::XML::Node *repr = getRepr();
     if (repr && repr->parent()) {
         sp_repr_unparent(repr);
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
index 9e641edc3..f2a256698 100644
--- a/src/ui/CMakeLists.txt
+++ b/src/ui/CMakeLists.txt
@@ -128,6 +128,7 @@ set(ui_SRC
 	widget/entity-entry.cpp
 	widget/entry.cpp
 	widget/filter-effect-chooser.cpp
+	widget/font-button.cpp
 	widget/font-variants.cpp
 	widget/frame.cpp
 	widget/highlight-picker.cpp
@@ -312,6 +313,7 @@ set(ui_SRC
 	widget/entity-entry.h
 	widget/entry.h
 	widget/filter-effect-chooser.h
+	widget/font-button.h
 	widget/font-variants.h
 	widget/frame.h
 	widget/highlight-picker.h
diff --git a/src/ui/dialog/livepatheffect-editor.cpp b/src/ui/dialog/livepatheffect-editor.cpp
index 459d8d4ee..73f8debd6 100644
--- a/src/ui/dialog/livepatheffect-editor.cpp
+++ b/src/ui/dialog/livepatheffect-editor.cpp
@@ -52,7 +52,7 @@ void lpeeditor_selection_changed (Inkscape::Selection * selection, gpointer data
 {
     LivePathEffectEditor *lpeeditor = static_cast<LivePathEffectEditor *>(data);
     lpeeditor->lpe_list_locked = false;
-    lpeeditor->onSelectionChanged(selection);
+    lpeeditor->onSelectionChanged(selection, true);
 }
 
 static void lpeeditor_selection_modified (Inkscape::Selection * selection, guint /*flags*/, gpointer data)
@@ -89,7 +89,8 @@ LivePathEffectEditor::LivePathEffectEditor()
       button_up(),
       button_down(),
       current_desktop(NULL),
-      current_lpeitem(NULL)
+      current_lpeitem(NULL),
+      current_lperef(NULL)
 {
     Gtk::Box *contents = _getContents();
     contents->set_spacing(4);
@@ -190,6 +191,10 @@ LivePathEffectEditor::~LivePathEffectEditor()
 void
 LivePathEffectEditor::showParams(LivePathEffect::Effect& effect)
 {
+    if ( ! effect.upd_params ) {
+        return;
+    }
+
     if (effectwidget) {
         effectcontrol_vbox.remove(*effectwidget);
         delete effectwidget;
@@ -249,9 +254,8 @@ LivePathEffectEditor::set_sensitize_all(bool sensitive)
     button_down.set_sensitive(sensitive);
 }
 
-
 void
-LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel)
+LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel, bool upd_params)
 {
     if (lpe_list_locked) {
         // this was triggered by selecting a row in the list, so skip reloading
@@ -275,6 +279,9 @@ LivePathEffectEditor::onSelectionChanged(Inkscape::Selection *sel)
                 if ( lpeitem->hasPathEffect() ) {
                     Inkscape::LivePathEffect::Effect *lpe = lpeitem->getCurrentLPE();
                     if (lpe) {
+                        if (upd_params) {
+                            lpe->upd_params = true;
+                        }
                         showParams(*lpe);
                         lpe_list_locked = true;
                         selectInList(lpe);
@@ -478,6 +485,12 @@ LivePathEffectEditor::onRemove()
         SPItem *item = sel->singleItem();
         SPLPEItem *lpeitem  = dynamic_cast<SPLPEItem *>(item);
         if ( lpeitem ) {
+            if (current_lperef && current_lperef->lpeobject) {
+                LivePathEffect::Effect * effect = current_lperef->lpeobject->get_lpe();
+                if (effect) {
+                    effect->upd_params = true;
+                }
+            }
             lpeitem->removeCurrentPathEffect(false);
 
             DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
@@ -532,11 +545,17 @@ void LivePathEffectEditor::on_effect_selection_changed()
     Gtk::TreeModel::iterator it = sel->get_selected();
     LivePathEffect::LPEObjectReference * lperef = (*it)[columns.lperef];
 
-    if (lperef && current_lpeitem) {
+    if (lperef && current_lpeitem && current_lperef != lperef) {
+    //The last condition ignore Gtk::TreeModel may occasionally be changed emitted when nothing has happened
         if (lperef->lpeobject->get_lpe()) {
             lpe_list_locked = true; // prevent reload of the list which would lose selection
             current_lpeitem->setCurrentPathEffect(lperef);
-            showParams(*lperef->lpeobject->get_lpe());
+            current_lperef = lperef;
+            LivePathEffect::Effect * effect = lperef->lpeobject->get_lpe();
+            if (effect) {
+                effect->upd_params = true;
+                showParams(*effect);
+            }
         }
     }
 }
@@ -554,6 +573,14 @@ void LivePathEffectEditor::on_visibility_toggled( Glib::ustring const& str )
         /* FIXME: this explicit writing to SVG is wrong. The lpe_item should have a method to disable/enable an effect within its stack.
          * So one can call:  lpe_item->setActive(lpeobjref->lpeobject); */
         lpeobjref->lpeobject->get_lpe()->getRepr()->setAttribute("is_visible", newValue ? "true" : "false");
+        Inkscape::Selection *sel = _getSelection();
+        if ( sel && !sel->isEmpty() ) {
+            SPItem *item = sel->singleItem();
+            SPLPEItem *lpeitem  = dynamic_cast<SPLPEItem *>(item);
+            if ( lpeitem ) {
+                lpeobjref->lpeobject->get_lpe()->doOnVisibilityToggled(lpeitem);
+            }
+        }
         DocumentUndo::done( current_desktop->getDocument(), SP_VERB_DIALOG_LIVE_PATH_EFFECT,
                             newValue ? _("Activate path effect") : _("Deactivate path effect"));
     }
diff --git a/src/ui/dialog/livepatheffect-editor.h b/src/ui/dialog/livepatheffect-editor.h
index b69ee007a..489e9564d 100644
--- a/src/ui/dialog/livepatheffect-editor.h
+++ b/src/ui/dialog/livepatheffect-editor.h
@@ -45,7 +45,8 @@ public:
 
     static LivePathEffectEditor &getInstance() { return *new LivePathEffectEditor(); }
 
-    void onSelectionChanged(Inkscape::Selection *sel);
+    void onSelectionChanged(Inkscape::Selection *sel, bool upd_params = false);
+    void onSelectionModified(Inkscape::Selection *sel);
     virtual void on_effect_selection_changed();
     void setDesktop(SPDesktop *desktop);
 
@@ -122,6 +123,8 @@ private:
     
     SPLPEItem * current_lpeitem;
 
+    LivePathEffect::LPEObjectReference * current_lperef;
+
     friend void lpeeditor_selection_changed (Inkscape::Selection * selection, gpointer data);
 
     LivePathEffectEditor(LivePathEffectEditor const &d);
diff --git a/src/ui/widget/combo-enums.h b/src/ui/widget/combo-enums.h
index 4678ab83b..e7524ac71 100644
--- a/src/ui/widget/combo-enums.h
+++ b/src/ui/widget/combo-enums.h
@@ -16,7 +16,6 @@
 #include <gtkmm/liststore.h>
 #include "attr-widget.h"
 #include "util/enums.h"
-
 #include <glibmm/i18n.h>
 
 namespace Inkscape {
@@ -190,9 +189,11 @@ public:
                           const Util::EnumDataConverter<E>& c,
                           Glib::ustring const &suffix = "",
                           Glib::ustring const &icon = "",
-                          bool mnemonic = true)
-        : Labelled(label, tooltip, new ComboBoxEnum<E>(c), suffix, icon, mnemonic)
-    { }
+                          bool mnemonic = true,
+                          bool sorted = true)
+        : Labelled(label, tooltip, new ComboBoxEnum<E>(c, SP_ATTR_INVALID, sorted), suffix, icon, mnemonic)
+    { 
+    }
 
     ComboBoxEnum<E>* getCombobox() {
         return static_cast< ComboBoxEnum<E>* > (_widget);
diff --git a/src/ui/widget/font-button.cpp b/src/ui/widget/font-button.cpp
new file mode 100644
index 000000000..a472ac6a4
--- /dev/null
+++ b/src/ui/widget/font-button.cpp
@@ -0,0 +1,58 @@
+/*
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "font-button.h"
+#include <glibmm/i18n.h>
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+FontButton::FontButton(Glib::ustring const &label, Glib::ustring const &tooltip,
+              Glib::ustring const &suffix,
+              Glib::ustring const &icon,
+              bool mnemonic)
+           : Labelled(label, tooltip, new Gtk::FontButton("Sans 10"), suffix, icon, mnemonic)
+{
+}
+
+Glib::ustring FontButton::getValue() const
+{
+    g_assert(_widget != NULL);
+    return static_cast<Gtk::FontButton*>(_widget)->get_font_name();
+}
+
+
+void FontButton::setValue (Glib::ustring fontspec)
+{
+    g_assert(_widget != NULL);
+    static_cast<Gtk::FontButton*>(_widget)->set_font_name(fontspec);
+}
+
+Glib::SignalProxy0<void> FontButton::signal_font_value_changed()
+{
+    g_assert(_widget != NULL);
+    return static_cast<Gtk::FontButton*>(_widget)->signal_font_set();
+}
+
+
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/font-button.h b/src/ui/widget/font-button.h
new file mode 100644
index 000000000..1f1ad2d01
--- /dev/null
+++ b/src/ui/widget/font-button.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * Copyright (C) 2007 Author
+ *
+ * Released under GNU GPL.  Read the file 'COPYING' for more information.
+ */
+
+#ifndef INKSCAPE_UI_WIDGET_FONT_BUTTON_H
+#define INKSCAPE_UI_WIDGET_FONT_BUTTON_H
+
+#include <gtkmm.h>
+#include "labelled.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Widget {
+
+/**
+ * A labelled font button for entering font values
+ */
+class FontButton : public Labelled
+{
+public:
+    /**
+     * Construct a FontButton Widget.
+     *
+     * @param label     Label.
+     * @param suffix    Suffix, placed after the widget (defaults to "").
+     * @param icon      Icon filename, placed before the label (defaults to "").
+     * @param mnemonic  Mnemonic toggle; if true, an underscore (_) in the label
+     *                  indicates the next character should be used for the
+     *                  mnemonic accelerator key (defaults to false).
+     */
+    FontButton( Glib::ustring const &label,
+           Glib::ustring const &tooltip,
+           Glib::ustring const &suffix = "",
+           Glib::ustring const &icon = "",
+           bool mnemonic = true);
+
+    Glib::ustring getValue() const;
+    void setValue (Glib::ustring fontspec);
+    /**
+    * Signal raised when the font button's value changes.
+    */
+    Glib::SignalProxy0<void> signal_font_value_changed();
+};
+
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#endif // INKSCAPE_UI_WIDGET_RANDOM_H
+
+/*
+  Local Variables:
+  mode:c++
+  c-file-style:"stroustrup"
+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+  indent-tabs-mode:nil
+  fill-column:99
+  End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/ui/widget/registered-enums.h b/src/ui/widget/registered-enums.h
index 9e1682c7d..1d5074836 100644
--- a/src/ui/widget/registered-enums.h
+++ b/src/ui/widget/registered-enums.h
@@ -33,11 +33,11 @@ public:
                 const Util::EnumDataConverter<E>& c,
                 Registry& wr,
                 Inkscape::XML::Node* repr_in = NULL,
-                SPDocument *doc_in = NULL )
-        : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c)
+                SPDocument *doc_in = NULL,
+                bool sorted = true )
+        : RegisteredWidget< LabelledComboBoxEnum<E> >(label, tip, c, (const Glib::ustring &)"", (const Glib::ustring &)"", true, sorted)
     {
         RegisteredWidget< LabelledComboBoxEnum<E> >::init_parent(key, wr, repr_in, doc_in);
-
         _changed_connection = combobox()->signal_changed().connect (sigc::mem_fun (*this, &RegisteredEnum::on_changed));
     }
 
diff --git a/src/ui/widget/registered-widget.cpp b/src/ui/widget/registered-widget.cpp
index 7dc5abc75..be677a434 100644
--- a/src/ui/widget/registered-widget.cpp
+++ b/src/ui/widget/registered-widget.cpp
@@ -285,7 +285,6 @@ RegisteredScalar::on_value_changed()
         setProgrammatically = false;
         return;
     }
-
     if (_wr->isUpdating()) {
         return;
     }
@@ -319,8 +318,6 @@ RegisteredText::RegisteredText ( const Glib::ustring& label, const Glib::ustring
     init_parent(key, wr, repr_in, doc_in);
 
     setProgrammatically = false;
-
-    setText("");
     _activate_connection = signal_activate().connect (sigc::mem_fun (*this, &RegisteredText::on_activate));
 }
 
@@ -336,16 +333,12 @@ RegisteredText::on_activate()
         return;
     }
     _wr->setUpdating (true);
-
-    Inkscape::SVGOStringStream os;
-    os << getText();
-
+    Glib::ustring str(getText());
     set_sensitive(false);
+    Inkscape::SVGOStringStream os;
+    os << str;
     write_to_xml(os.str().c_str());
     set_sensitive(true);
-
-    setText(os.str().c_str());
-
     _wr->setUpdating (false);
 }
 
@@ -791,6 +784,47 @@ RegisteredRandom::on_value_changed()
     _wr->setUpdating (false);
 }
 
+/*#########################################
+ * Registered FONT-BUTTON
+ */
+
+RegisteredFontButton::~RegisteredFontButton()
+{
+    _signal_font_set.disconnect();
+}
+
+RegisteredFontButton::RegisteredFontButton ( const Glib::ustring& label, const Glib::ustring& tip,
+                        const Glib::ustring& key, Registry& wr, Inkscape::XML::Node* repr_in,
+                        SPDocument* doc_in )
+    : RegisteredWidget<FontButton>(label, tip)
+{
+    init_parent(key, wr, repr_in, doc_in);
+    _signal_font_set =  signal_font_value_changed().connect (sigc::mem_fun (*this, &RegisteredFontButton::on_value_changed));
+}
+
+void
+RegisteredFontButton::setValue (Glib::ustring fontspec)
+{
+    FontButton::setValue(fontspec);
+}
+
+void
+RegisteredFontButton::on_value_changed()
+{
+
+    if (_wr->isUpdating())
+        return;
+
+    _wr->setUpdating (true);
+
+    Inkscape::SVGOStringStream os;
+    os << getValue();
+
+    write_to_xml(os.str().c_str());
+
+    _wr->setUpdating (false);
+}
+
 } // namespace Dialog
 } // namespace UI
 } // namespace Inkscape
diff --git a/src/ui/widget/registered-widget.h b/src/ui/widget/registered-widget.h
index ab2e4c8e4..d410dbfe6 100644
--- a/src/ui/widget/registered-widget.h
+++ b/src/ui/widget/registered-widget.h
@@ -22,6 +22,7 @@
 #include "ui/widget/text.h"
 #include "ui/widget/random.h"
 #include "ui/widget/unit-menu.h"
+#include "ui/widget/font-button.h"
 #include "ui/widget/color-picker.h"
 #include "inkscape.h"
 
@@ -77,6 +78,8 @@ protected:
     RegisteredWidget( A& a, B& b, C c, D d ): W( a, b, c, d ) { construct(); }
     template< typename A, typename B, typename C, typename D, typename E , typename F>
     RegisteredWidget( A& a, B& b, C c, D& d, E& e, F* f): W( a, b, c, d, e, f) { construct(); }
+    template< typename A, typename B, typename C, typename D, typename E , typename F, typename G>
+    RegisteredWidget( A& a, B& b, C& c, D& d, E& e, F f, G& g): W( a, b, c, d, e, f, g) { construct(); }
 
     virtual ~RegisteredWidget() {};
 
@@ -418,6 +421,23 @@ protected:
     void on_value_changed();
 };
 
+class RegisteredFontButton : public RegisteredWidget<FontButton> {
+public:
+    virtual ~RegisteredFontButton();
+    RegisteredFontButton ( const Glib::ustring& label,
+                             const Glib::ustring& tip,
+                             const Glib::ustring& key,
+                             Registry& wr,
+                             Inkscape::XML::Node* repr_in = NULL,
+                             SPDocument *doc_in = NULL);
+
+    void setValue (Glib::ustring fontspec);
+
+protected:
+    sigc::connection  _signal_font_set;
+    void on_value_changed();
+};
+
 } // namespace Widget
 } // namespace UI
 } // namespace Inkscape
diff --git a/src/ui/widget/scalar.cpp b/src/ui/widget/scalar.cpp
index 434c2c0bb..f8543a371 100644
--- a/src/ui/widget/scalar.cpp
+++ b/src/ui/widget/scalar.cpp
@@ -122,10 +122,12 @@ void Scalar::setRange(double min, double max)
     static_cast<SpinButton*>(_widget)->set_range(min, max);
 }
 
-void Scalar::setValue(double value)
+void Scalar::setValue(double value, bool setProg)
 {
     g_assert(_widget != NULL);
-    setProgrammatically = true; // callback is supposed to reset back, if it cares
+    if (setProg) {
+        setProgrammatically = true; // callback is supposed to reset back, if it cares
+    }
     static_cast<SpinButton*>(_widget)->set_value(value);
 }
 
diff --git a/src/ui/widget/scalar.h b/src/ui/widget/scalar.h
index 847790b96..f186f46ac 100644
--- a/src/ui/widget/scalar.h
+++ b/src/ui/widget/scalar.h
@@ -135,7 +135,7 @@ public:
     /**
      * Sets the value of the spin button.
      */
-    void    setValue(double value);
+    void    setValue(double value, bool setProg = true);
 
     /**
      * Manually forces an update of the spin button.
diff --git a/src/ui/widget/text.cpp b/src/ui/widget/text.cpp
index ec58d5bb4..e6795b138 100644
--- a/src/ui/widget/text.cpp
+++ b/src/ui/widget/text.cpp
@@ -28,13 +28,13 @@ Text::Text(Glib::ustring const &label, Glib::ustring const &tooltip,
 {
 }
 
-const char *Text::getText() const
+Glib::ustring const Text::getText() const
 {
     g_assert(_widget != NULL);
-    return static_cast<Gtk::Entry*>(_widget)->get_text().c_str();
+    return static_cast<Gtk::Entry*>(_widget)->get_text();
 }
 
-void Text::setText(const char* text)
+void Text::setText(Glib::ustring const text)
 {
     g_assert(_widget != NULL);
     setProgrammatically = true; // callback is supposed to reset back, if it cares
diff --git a/src/ui/widget/text.h b/src/ui/widget/text.h
index b90788940..593875b23 100644
--- a/src/ui/widget/text.h
+++ b/src/ui/widget/text.h
@@ -44,12 +44,12 @@ public:
     /**
      * Get the text in the entry.
      */
-    const char* getText() const;
+    Glib::ustring const getText() const;
 
     /**
      * Sets the text of the text entry.
      */
-    void setText(const char* text);
+    void setText(Glib::ustring const text);
 
     void update();