update to trunk

(bzr r13645.1.4)

25 files changed, 385 insertions, 387 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 1a64defd9..827f70749 100644
--- a/src/live_effects/effect.cpp
+++ b/src/live_effects/effect.cpp
@@ -75,8 +75,6 @@
 #include <glibmm/i18n.h>
 #include "ui/tools/pen-tool.h"
 #include "ui/tools-switch.h"
-#include "message-stack.h"
-#include "desktop.h"
 #include "knotholder.h"
 #include "sp-lpe-item.h"
 #include "live_effects/lpeobject.h"
@@ -370,6 +368,7 @@ Effect::Effect(LivePathEffectObject *lpeobject)
 {
     registerParameter( dynamic_cast<Parameter *>(&is_visible) );
     is_visible.widget_is_visible = false;
+    current_zoom = 0.0;
 }
 
 Effect::~Effect()
@@ -398,6 +397,38 @@ Effect::doOnApply (SPLPEItem const*/*lpeitem*/)
 {
 }
 
+void
+Effect::setSelectedNodePoints(std::vector<Geom::Point> sNP)
+{
+    selectedNodesPoints = sNP;
+}
+
+void
+Effect::setCurrentZoom(double cZ)
+{
+    current_zoom = cZ;
+}
+
+bool
+Effect::isNodePointSelected(Geom::Point const &nodePoint) const
+{
+    if (selectedNodesPoints.size() > 0) {
+        using Geom::X;
+        using Geom::Y; 
+        for (std::vector<Geom::Point>::const_iterator i = selectedNodesPoints.begin();
+                i != selectedNodesPoints.end(); ++i) {
+            Geom::Point p = *i;
+            Geom::Affine transformCoordinate = sp_lpe_item->i2dt_affine();
+            Geom::Point p2(nodePoint[X],nodePoint[Y]);
+            p2 *= transformCoordinate;
+            if (Geom::are_near(p, p2, 0.01)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 /**
  * Is performed each time before the effect is updated.
  */
@@ -419,6 +450,7 @@ void Effect::doOnRemove (SPLPEItem const* /*lpeitem*/)
 void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
 {
     sp_lpe_item = const_cast<SPLPEItem *>(lpeitem);
+    defaultUnit = &sp_lpe_item->document->getDisplayUnit()->abbr;
     /*sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
     pathvector_before_effect = sp_curve->get_pathvector();*/
     doOnApply(lpeitem);
@@ -427,6 +459,7 @@ void Effect::doOnApply_impl(SPLPEItem const* lpeitem)
 void Effect::doBeforeEffect_impl(SPLPEItem const* lpeitem)
 {
     sp_lpe_item = const_cast<SPLPEItem *>(lpeitem);
+    defaultUnit = &sp_lpe_item->document->getDisplayUnit()->abbr;
     //printf("(SPLPEITEM*) %p\n", sp_lpe_item);
     sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
     pathvector_before_effect = sp_curve->get_pathvector();
@@ -443,7 +476,7 @@ void
 Effect::doAcceptPathPreparations(SPLPEItem *lpeitem)
 {
     // switch to pen context
-    SPDesktop *desktop = inkscape_active_desktop(); // TODO: Is there a better method to find the item's desktop?
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP; // TODO: Is there a better method to find the item's desktop?
     if (!tools_isactive(desktop, TOOLS_FREEHAND_PEN)) {
         tools_switch(desktop, TOOLS_FREEHAND_PEN);
     }
diff --git a/src/live_effects/effect.h b/src/live_effects/effect.h
index a486e8491..7da76b267 100644
--- a/src/live_effects/effect.h
+++ b/src/live_effects/effect.h
@@ -13,6 +13,7 @@
 #include "parameter/bool.h"
 #include "effect-enum.h"
 
+
 #define  LPE_CONVERSION_TOLERANCE 0.01    // FIXME: find good solution for this.
 
 class  SPDocument;
@@ -57,7 +58,9 @@ public:
     //of indirection is needed. We first call these methods, then the below.
     void doOnApply_impl(SPLPEItem const* lpeitem);
     void doBeforeEffect_impl(SPLPEItem const* lpeitem);
-
+    void setCurrentZoom(double cZ);
+    void setSelectedNodePoints(std::vector<Geom::Point> sNP);
+    bool isNodePointSelected(Geom::Point const &nodePoint) const;
     virtual void doOnApply (SPLPEItem const* lpeitem);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
     
@@ -156,6 +159,9 @@ protected:
     bool concatenate_before_pwd2;
 
     SPLPEItem * sp_lpe_item; // these get stored in doBeforeEffect_impl, and derived classes may do as they please with them.
+    Glib::ustring const * defaultUnit; // these get stored in doBeforeEffect_impl, and derived classes may do as they please with them.
+    double current_zoom;
+    std::vector<Geom::Point> selectedNodesPoints;
     SPCurve * sp_curve;
     std::vector<Geom::Path> pathvector_before_effect;
 private:
diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp
index b68799d08..2bed90139 100644
--- a/src/live_effects/lpe-bspline.cpp
+++ b/src/live_effects/lpe-bspline.cpp
@@ -24,11 +24,6 @@
 #include "live_effects/lpeobject.h"
 #include "live_effects/parameter/parameter.h"
 #include "ui/widget/scalar.h"
-#include "ui/tool/node.h"
-#include "ui/tools/node-tool.h"
-#include "ui/tool/control-point-selection.h"
-#include "ui/tool/selectable-control-point.h"
-#include "selection.h"
 #include "xml/repr.h"
 #include "svg/svg.h"
 #include "sp-path.h"
@@ -36,7 +31,6 @@
 #include "document-private.h"
 #include "document.h"
 #include "document-undo.h"
-#include "desktop-handles.h"
 #include "verbs.h"
 #include "sp-lpe-item.h"
 #include "sp-namedview.h"
@@ -47,7 +41,6 @@
 // For handling un-continuous paths:
 #include "message-stack.h"
 #include "inkscape.h"
-#include "desktop.h"
 
 using Inkscape::DocumentUndo;
 
@@ -64,7 +57,7 @@ LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject)
       // initialise your parameters here:
       //testpointA(_("Test Point A"), _("Test A"), "ptA", &wr, this,
       //Geom::Point(100,100)),
-      steps(_("Steps whith CTRL:"), _("Change number of steps whith CTRL pressed"), "steps", &wr, this, 2),
+      steps(_("Steps with CTRL:"), _("Change number of steps with CTRL pressed"), "steps", &wr, this, 2),
       ignoreCusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true),
       onlySelected(_("Change only selected nodes"), _("Change only selected nodes"), "onlySelected", &wr, this, false),
       showHelper(_("Show helper paths"), _("Show helper paths"), "showHelper", &wr, this, false),
@@ -87,7 +80,7 @@ LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject)
 
 LPEBSpline::~LPEBSpline() {}
 
-void LPEBSpline::doBeforeEffect (SPLPEItem const* lpeitem)
+void LPEBSpline::doBeforeEffect (SPLPEItem const* /*lpeitem*/)
 {
     if(!hp.empty()){
         hp.clear();
@@ -95,25 +88,12 @@ void LPEBSpline::doBeforeEffect (SPLPEItem const* lpeitem)
 }
 
 
-void LPEBSpline::createAndApply(const char *name, SPDocument *doc,
-                                SPItem *item)
+void LPEBSpline::doOnApply(SPLPEItem const* lpeitem)
 {
-    if (!SP_IS_SHAPE(item)) {
+    if (!SP_IS_SHAPE(lpeitem)) {
         g_warning("LPE BSpline can only be applied to shapes (not groups).");
-    } else {
-        // Path effect definition
-        Inkscape::XML::Document *xml_doc = doc->getReprDoc();
-        Inkscape::XML::Node *repr = xml_doc->createElement("inkscape:path-effect");
-        repr->setAttribute("effect", name);
-
-        doc->getDefs()->getRepr()
-        ->addChild(repr, NULL); // adds to <defs> and assigns the 'id' attribute
-        const gchar *repr_id = repr->attribute("id");
-        Inkscape::GC::release(repr);
-
-        gchar *href = g_strdup_printf("#%s", repr_id);
-        SP_LPE_ITEM(item)->addPathEffect(href, true);
-        g_free(href);
+        SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+        item->removeCurrentPathEffect(false);
     }
 }
 
@@ -127,12 +107,8 @@ void LPEBSpline::doEffect(SPCurve *curve)
     Geom::PathVector const original_pathv = curve->get_pathvector();
     curve->reset();
     double radiusHelperNodes = 6.0;
-    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
-    if (desktop){
-        radiusHelperNodes /= SP_ACTIVE_DESKTOP->current_zoom();
-        SPNamedView *nv = sp_desktop_namedview(desktop);
-        radiusHelperNodes = Inkscape::Util::Quantity::convert(radiusHelperNodes, "px", nv->doc_units->abbr);
-    }
+    radiusHelperNodes /= current_zoom;
+    radiusHelperNodes = Inkscape::Util::Quantity::convert(radiusHelperNodes, "px", *defaultUnit);
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
         if (path_it->empty())
@@ -165,16 +141,8 @@ void LPEBSpline::doEffect(SPCurve *curve)
                 curve_endit = path_it->end_open();
             }
         }
-        //Si la curva está cerrada calculamos el punto donde
-        //deveria estar el nodo BSpline de cierre/inicio de la curva
-        //en posible caso de que se cierre con una linea recta creando un nodo
-        //BSPline
         nCurve->moveto(curve_it1->initialPoint());
-        //Recorremos todos los segmentos menos el último
         while (curve_it1 != curve_endit) {
-            //previousPointAt3 = pointAt3;
-            //Calculamos los puntos que dividirían en tres segmentos iguales el path
-            //recto de entrada y de salida
             SPCurve *in = new SPCurve();
             in->moveto(curve_it1->initialPoint());
             in->lineto(curve_it1->finalPoint());
@@ -260,10 +228,7 @@ void LPEBSpline::doEffect(SPCurve *curve)
                 SBasisHelper = lineHelper->first_segment()->toSBasis();
                 lineHelper->reset();
                 delete lineHelper;
-                //almacenamos el punto del anterior bucle -o el de cierre- que nos hara de
-                //principio de curva
                 previousNode = node;
-                //Y este hará de final de curva
                 node = SBasisHelper.valueAt(0.5);
                 Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
                 if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) {
@@ -274,12 +239,6 @@ void LPEBSpline::doEffect(SPCurve *curve)
             if(!are_near(node,curve_it1->finalPoint()) && showHelper){
                 drawHandle(node, radiusHelperNodes);
             }
-            //La curva BSpline se forma calculando el centro del segmanto de unión
-            //de el punto situado en las 2/3 partes de el segmento de entrada
-            //con el punto situado en la posición 1/3 del segmento de salida
-            //Estos dos puntos ademas estan posicionados en el lugas correspondiente
-            //de los manejadores de la curva
-            //aumentamos los valores para el siguiente paso en el bucle
             ++curve_it1;
             ++curve_it2;
         }
@@ -293,7 +252,7 @@ void LPEBSpline::doEffect(SPCurve *curve)
     }
     if(showHelper){
         Geom::PathVector const pathv = curve->get_pathvector();
-        hp.push_back(pathv[0]);
+         hp.push_back(pathv[0]);
     }
 }
 
@@ -314,7 +273,6 @@ LPEBSpline::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::
 {
     hp_vec.push_back(hp);
 }
-
 Gtk::Widget *LPEBSpline::newWidget()
 {
     // use manage here, because after deletion of Effect object, others might
@@ -332,12 +290,12 @@ Gtk::Widget *LPEBSpline::newWidget()
                 Gtk::Button *defaultWeight =
                     Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight"))));
                 defaultWeight->signal_clicked()
-                .connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight), widg));
+                .connect(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight));
                 buttons->pack_start(*defaultWeight, true, true, 2);
                 Gtk::Button *makeCusp =
                     Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp"))));
                 makeCusp->signal_clicked()
-                .connect(sigc::bind<Gtk::Widget *>(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp), widg));
+                .connect(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp));
                 buttons->pack_start(*makeCusp, true, true, 2);
                 vbox->pack_start(*buttons, true, true, 2);
             }
@@ -381,24 +339,14 @@ Gtk::Widget *LPEBSpline::newWidget()
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
-void LPEBSpline::toDefaultWeight(Gtk::Widget *widgWeight)
+void LPEBSpline::toDefaultWeight()
 {
-    weight.param_set_value(defaultStartPower);
     changeWeight(defaultStartPower);
-    Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widgWeight);
-    std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
-    Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-    entryWidg->set_text("defaultStartPower");
 }
 
-void LPEBSpline::toMakeCusp(Gtk::Widget *widgWeight)
+void LPEBSpline::toMakeCusp()
 {
-    weight.param_set_value(noPower);
     changeWeight(noPower);
-    Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widgWeight);
-    std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
-    Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
-    entryWidg->set_text("noPower");
 }
 
 void LPEBSpline::toWeight()
@@ -408,91 +356,34 @@ void LPEBSpline::toWeight()
 
 void LPEBSpline::changeWeight(double weightValue)
 {
-    SPDesktop *desktop = inkscape_active_desktop();
-    Inkscape::Selection *selection = sp_desktop_selection(desktop);
-    GSList *items = (GSList *)selection->itemList();
-    SPItem *item = (SPItem *)g_slist_nth(items, 0)->data;
-    SPPath *path = SP_PATH(item);
+    SPPath *path = SP_PATH(sp_lpe_item);
     SPCurve *curve = path->get_curve_for_edit();
     LPEBSpline::doBSplineFromWidget(curve, weightValue);
     gchar *str = sp_svg_write_path(curve->get_pathvector());
     path->getRepr()->setAttribute("inkscape:original-d", str);
-    if (INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
-        nt->desktop->updateNow();
-    }
-    g_free(str);
-    curve->unref();
-    desktop->clearWaitingCursor();
-    DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_LPE,
-                       _("Modified the weight of the BSpline"));
-}
-
-bool LPEBSpline::nodeIsSelected(Geom::Point nodePoint)
-{
-    using Geom::X;
-    using Geom::Y;
-
-    if (points.size() > 0) {
-        for (std::vector<Geom::Point>::iterator i = points.begin();
-                i != points.end(); ++i) {
-            Geom::Point p = *i;
-            if (Geom::are_near(p, nodePoint, handleCubicGap)) {
-                return true;
-            } else {
-            }
-        }
-    }
-    return false;
 }
 
 void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
 {
     using Geom::X;
     using Geom::Y;
-    SPDesktop *desktop = inkscape_active_desktop();
-    if (INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nt = INK_NODE_TOOL(desktop->event_context);
-        Inkscape::UI::ControlPointSelection::Set &selection =
-            nt->_selected_nodes->allPoints();
-        points.clear();
-        std::vector<Geom::Point>::iterator pbegin;
-        for (Inkscape::UI::ControlPointSelection::Set::iterator i =
-                    selection.begin();
-                i != selection.end(); ++i) {
-            if ((*i)->selected()) {
-                Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
-                pbegin = points.begin();
-                points.insert(pbegin, desktop->doc2dt(n->position()));
-            }
-        }
-    }
-    //bool hasNodesSelected = LPEBspline::hasNodesSelected();
+    
     if (curve->get_segment_count() < 1)
         return;
     // Make copy of old path as it is changed during processing
     Geom::PathVector const original_pathv = curve->get_pathvector();
     curve->reset();
 
-    //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el
-    //penúltimo
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
-        //Si está vacío...
-        if (path_it->empty())
+
+        if (path_it->empty()){
             continue;
-        //Itreadores
-
-        Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve
-        Geom::Path::const_iterator curve_it2 =
-            ++(path_it->begin());                                // outgoing curve
-        Geom::Path::const_iterator curve_endit =
-            path_it->end_default(); // this determines when the loop has to stop
-        //Creamos las lineas rectas que unen todos los puntos del trazado y donde se
-        //calcularán
-        //los puntos clave para los manejadores.
-        //Esto hace que la curva BSpline no pierda su condición aunque se trasladen
-        //dichos manejadores
+        }
+        Geom::Path::const_iterator curve_it1 = path_it->begin();
+        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
+        Geom::Path::const_iterator curve_endit = path_it->end_default();
+
         SPCurve *nCurve = new SPCurve();
         Geom::Point pointAt0(0, 0);
         Geom::Point pointAt1(0, 0);
@@ -515,16 +406,8 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                 curve_endit = path_it->end_open();
             }
         }
-        //Si la curva está cerrada calculamos el punto donde
-        //deveria estar el nodo BSpline de cierre/inicio de la curva
-        //en posible caso de que se cierre con una linea recta creando un nodo
-        //BSPline
         nCurve->moveto(curve_it1->initialPoint());
-        //Recorremos todos los segmentos menos el último
         while (curve_it1 != curve_endit) {
-            //previousPointAt3 = pointAt3;
-            //Calculamos los puntos que dividirían en tres segmentos iguales el path
-            //recto de entrada y de salida
             SPCurve *in = new SPCurve();
             in->moveto(curve_it1->initialPoint());
             in->lineto(curve_it1->finalPoint());
@@ -572,7 +455,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
             } else {
                 if (cubic) {
                     if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-                        if (nodeIsSelected(pointAt0)) {
+                        if (isNodePointSelected(pointAt0)) {
                             pointAt1 = SBasisIn.valueAt(weightValue);
                             if (weightValue != noPower) {
                                 pointAt1 =
@@ -585,7 +468,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                         pointAt1 = in->first_segment()->initialPoint();
                     }
                     if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-                        if (nodeIsSelected(pointAt3)) {
+                        if (isNodePointSelected(pointAt3)) {
                             pointAt2 = SBasisIn.valueAt(1 - weightValue);
                             if (weightValue != noPower) {
                                 pointAt2 =
@@ -599,14 +482,14 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                     }
                 } else {
                     if (!ignoreCusp && weightValue != noPower) {
-                        if (nodeIsSelected(pointAt0)) {
+                        if (isNodePointSelected(pointAt0)) {
                             pointAt1 = SBasisIn.valueAt(weightValue);
                             pointAt1 =
                                 Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap);
                         } else {
                             pointAt1 = in->first_segment()->initialPoint();
                         }
-                        if (nodeIsSelected(pointAt3)) {
+                        if (isNodePointSelected(pointAt3)) {
                             pointAt2 = SBasisIn.valueAt(weightValue);
                             pointAt2 =
                                 Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
@@ -621,14 +504,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
             }
             in->reset();
             delete in;
-            //La curva BSpline se forma calculando el centro del segmanto de unión
-            //de el punto situado en las 2/3 partes de el segmento de entrada
-            //con el punto situado en la posición 1/3 del segmento de salida
-            //Estos dos puntos ademas estan posicionados en el lugas correspondiente
-            //de
-            //los manejadores de la curva
             nCurve->curveto(pointAt1, pointAt2, pointAt3);
-            //aumentamos los valores para el siguiente paso en el bucle
             ++curve_it1;
             ++curve_it2;
         }
@@ -638,7 +514,6 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
         } else {
             nCurve->move_endpoints(path_it->begin()->initialPoint(), pointAt3);
         }
-        //y cerramos la curva
         if (path_it->closed()) {
             nCurve->closepath_current();
         }
diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h
index 169658b94..a17c0c4ac 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -19,27 +19,25 @@ public:
     LPEBSpline(LivePathEffectObject *lpeobject);
     virtual ~LPEBSpline();
 
-    virtual void createAndApply(const char *name, SPDocument *doc, SPItem *item);
     virtual LPEPathFlashType pathFlashType() const {
         return SUPPRESS_FLASH;
     }
+    virtual void doOnApply(SPLPEItem const* lpeitem);
     virtual void doEffect(SPCurve *curve);
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
     void drawHandle(Geom::Point p, double radiusHelperNodes);
-    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
     virtual void doBSplineFromWidget(SPCurve *curve, double value);
-    virtual bool nodeIsSelected(Geom::Point nodePoint);
+    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
     virtual Gtk::Widget *newWidget();
     virtual void changeWeight(double weightValue);
-    virtual void toDefaultWeight(Gtk::Widget *widgWeight);
-    virtual void toMakeCusp(Gtk::Widget *widgWeight);
+    virtual void toDefaultWeight();
+    virtual void toMakeCusp();
     virtual void toWeight();
 
     // TODO make this private
     ScalarParam steps;
 
 private:
-    std::vector<Geom::Point> points;
     BoolParam ignoreCusp;
     BoolParam onlySelected;
     BoolParam showHelper;
diff --git a/src/live_effects/lpe-copy_rotate.cpp b/src/live_effects/lpe-copy_rotate.cpp
index e466093d3..0fa2ebedc 100644
--- a/src/live_effects/lpe-copy_rotate.cpp
+++ b/src/live_effects/lpe-copy_rotate.cpp
@@ -15,9 +15,6 @@
 #include <gdk/gdk.h>
 
 #include "live_effects/lpe-copy_rotate.h"
-#include "sp-shape.h"
-#include "display/curve.h"
-
 #include <2geom/path.h>
 #include <2geom/transforms.h>
 #include <2geom/d2-sbasis.h>
@@ -45,24 +42,33 @@ public:
     virtual Geom::Point knot_get() const;
 };
 
+class KnotHolderEntityOrigin : public LPEKnotHolderEntity {
+public:
+    KnotHolderEntityOrigin(LPECopyRotate *effect) : LPEKnotHolderEntity(effect) {};
+    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin, guint state);
+    virtual Geom::Point knot_get() const;
+};
+
 } // namespace CR
 
 LPECopyRotate::LPECopyRotate(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
+    origin(_("Origin"), _("Origin of the rotation"), "origin", &wr, this, "Adjust the origin of the rotation"),
     starting_angle(_("Starting:"), _("Angle of the first copy"), "starting_angle", &wr, this, 0.0),
     rotation_angle(_("Rotation angle:"), _("Angle between two successive copies"), "rotation_angle", &wr, this, 30.0),
     num_copies(_("Number of copies:"), _("Number of copies of the original path"), "num_copies", &wr, this, 5),
-    origin(_("Origin"), _("Origin of the rotation"), "origin", &wr, this, "Adjust the origin of the rotation"),
-    dist_angle_handle(100)
+    copiesTo360(_("360º Copies"), _("No rotation angle, fixed to 360º"), "copiesTo360", &wr, this, true),
+    dist_angle_handle(100.0)
 {
     show_orig_path = true;
     _provides_knotholder_entities = true;
 
     // register all your parameters here, so Inkscape knows which parameters this effect has:
-    registerParameter( dynamic_cast<Parameter *>(&starting_angle) );
-    registerParameter( dynamic_cast<Parameter *>(&rotation_angle) );
-    registerParameter( dynamic_cast<Parameter *>(&num_copies) );
-    registerParameter( dynamic_cast<Parameter *>(&origin) );
+    registerParameter(&copiesTo360);
+    registerParameter(&starting_angle);
+    registerParameter(&rotation_angle);
+    registerParameter(&num_copies);
+    registerParameter(&origin);
 
     num_copies.param_make_integer(true);
     num_copies.param_set_range(0, 1000);
@@ -76,42 +82,58 @@ LPECopyRotate::~LPECopyRotate()
 void
 LPECopyRotate::doOnApply(SPLPEItem const* lpeitem)
 {
-    SPCurve const *curve = SP_SHAPE(lpeitem)->_curve;
-
-    A = *(curve->first_point());
-    B = *(curve->last_point());
+    using namespace Geom;
+    original_bbox(lpeitem);
 
+    A = Point(boundingbox_X.min(), boundingbox_Y.middle());
+    B = Point(boundingbox_X.middle(), boundingbox_Y.middle());
     origin.param_setValue(A);
-
-    dir = unit_vector(B - A);
     dist_angle_handle = L2(B - A);
+    dir = unit_vector(B - A);
 }
 
-Geom::Piecewise<Geom::D2<Geom::SBasis> >
-LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
+
+void
+LPECopyRotate::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     using namespace Geom;
-
+    original_bbox(lpeitem);
+    if(copiesTo360 ){
+        rotation_angle.param_set_value(360.0/(double)num_copies);
+    } 
+    A = Point(boundingbox_X.min(), boundingbox_Y.middle());
+    B = Point(boundingbox_X.middle(), boundingbox_Y.middle());
+    dir = unit_vector(B - A);
     // I first suspected the minus sign to be a bug in 2geom but it is
     // likely due to SVG's choice of coordinate system orientation (max)
     start_pos = origin + dir * Rotate(-deg_to_rad(starting_angle)) * dist_angle_handle;
-    rot_pos = origin + dir * Rotate(-deg_to_rad(starting_angle + rotation_angle)) * dist_angle_handle;
+    rot_pos = origin + dir * Rotate(-deg_to_rad(rotation_angle+starting_angle)) * dist_angle_handle;
+    if(copiesTo360 ){
+        rot_pos = origin;
+    }
+    SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+    item->apply_to_clippath(item);
+    item->apply_to_mask(item);
 
-    A = pwd2_in.firstValue();
-    B = pwd2_in.lastValue();
-    dir = unit_vector(B - A);
+}
 
-    Piecewise<D2<SBasis> > output;
 
+Geom::Piecewise<Geom::D2<Geom::SBasis> >
+LPECopyRotate::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
+{
+    using namespace Geom;
+
+    if(num_copies == 1){
+        return pwd2_in;
+    }
+
+    Piecewise<D2<SBasis> > output;
     Affine pre = Translate(-origin) * Rotate(-deg_to_rad(starting_angle));
     for (int i = 0; i < num_copies; ++i) {
-        // I first suspected the minus sign to be a bug in 2geom but it is
-        // likely due to SVG's choice of coordinate system orientation (max)
         Rotate rot(-deg_to_rad(rotation_angle * i));
         Affine t = pre * rot * Translate(origin);
         output.concat(pwd2_in * t);
     }
-
     return output;
 }
 
@@ -119,29 +141,37 @@ void
 LPECopyRotate::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
 {
     using namespace Geom;
-
-    Path path(start_pos);
-    path.appendNew<LineSegment>((Geom::Point) origin);
-    path.appendNew<LineSegment>(rot_pos);
-
-    PathVector pathv;
-    pathv.push_back(path);
+    hp_vec.clear();
+    Geom::Path hp;
+    hp.start(start_pos);
+    hp.appendNew<Geom::LineSegment>((Geom::Point)origin);
+    hp.appendNew<Geom::LineSegment>(origin + dir * Rotate(-deg_to_rad(rotation_angle+starting_angle)) * dist_angle_handle);
+    Geom::PathVector pathv;
+    pathv.push_back(hp);
     hp_vec.push_back(pathv);
 }
 
+
 void LPECopyRotate::addKnotHolderEntities(KnotHolder *knotholder, SPDesktop *desktop, SPItem *item) {
     {
         KnotHolderEntity *e = new CR::KnotHolderEntityStartingAngle(this);
         e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the starting angle") );
+                   _("Adjust the starting angle"));
         knotholder->add(e);
     }
     {
         KnotHolderEntity *e = new CR::KnotHolderEntityRotationAngle(this);
         e->create( desktop, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN,
-                   _("Adjust the rotation angle") );
+                   _("Adjust the rotation angle"));
         knotholder->add(e);
     }
+}
+
+void
+LPECopyRotate::resetDefaults(SPItem const* item)
+{
+    Effect::resetDefaults(item);
+    original_bbox(SP_LPE_ITEM(item));
 };
 
 namespace CR {
@@ -204,8 +234,6 @@ KnotHolderEntityRotationAngle::knot_get() const
 
 } // namespace CR
 
-
-
 /* ######################## */
 
 } //namespace LivePathEffect
diff --git a/src/live_effects/lpe-copy_rotate.h b/src/live_effects/lpe-copy_rotate.h
index ca7aa269c..9392026a7 100644
--- a/src/live_effects/lpe-copy_rotate.h
+++ b/src/live_effects/lpe-copy_rotate.h
@@ -16,6 +16,7 @@
 
 #include "live_effects/effect.h"
 #include "live_effects/parameter/point.h"
+#include "live_effects/lpegroupbbox.h"
 
 namespace Inkscape {
 namespace LivePathEffect {
@@ -26,7 +27,7 @@ namespace CR {
   class KnotHolderEntityRotationAngle;
 }
 
-class LPECopyRotate : public Effect {
+class LPECopyRotate : public Effect, GroupBBoxEffect {
 public:
     LPECopyRotate(LivePathEffectObject *lpeobject);
     virtual ~LPECopyRotate();
@@ -35,6 +36,10 @@ public:
 
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
 
+    virtual void doBeforeEffect (SPLPEItem const* lpeitem);
+
+    virtual void resetDefaults(SPItem const* item);
+
     /* the knotholder entity classes must be declared friends */
     friend class CR::KnotHolderEntityStartingAngle;
     friend class CR::KnotHolderEntityRotationAngle;
@@ -44,11 +49,11 @@ protected:
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
 
 private:
+    PointParam origin;
     ScalarParam starting_angle;
     ScalarParam rotation_angle;
     ScalarParam num_copies;
-
-    PointParam origin;
+    BoolParam copiesTo360;
 
     Geom::Point A;
     Geom::Point B;
diff --git a/src/live_effects/lpe-fillet-chamfer.cpp b/src/live_effects/lpe-fillet-chamfer.cpp
index 8a8f68d80..d2bdf2d8d 100644
--- a/src/live_effects/lpe-fillet-chamfer.cpp
+++ b/src/live_effects/lpe-fillet-chamfer.cpp
@@ -28,12 +28,7 @@
 #include "live_effects/parameter/filletchamferpointarray.h"
 
 // for programmatically updating knots
-#include "selection.h"
 #include "ui/tools-switch.h"
-#include "ui/tool/control-point-selection.h"
-#include "ui/tool/selectable-control-point.h"
-#include "ui/tool/node.h"
-#include "ui/tools/node-tool.h"
 #include <util/units.h>
 
 // TODO due to internal breakage in glibmm headers, this must be last:
@@ -62,15 +57,18 @@ LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
     only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
     flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"), "flexible", &wr, this, false),
     use_knot_distance(_("Use knots distance instead radius"), _("Use knots distance instead radius"), "use_knot_distance", &wr, this, false),
-    unit(_("Unit"), _("Unit"), "unit", &wr, this),
-    method(_("Method"), _("Fillets methods"), "method", FMConverter, &wr, this, FM_AUTO),
-    radius(_("Radius (unit or %)"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
-    helper_size(_("Helper size with direction"), _("Helper size with direction"), "helper_size", &wr, this, 0)
+    unit(_("Unit:"), _("Unit"), "unit", &wr, this),
+    method(_("Method:"), _("Fillets methods"), "method", FMConverter, &wr, this, FM_AUTO),
+    radius(_("Radius (unit or %):"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
+    chamfer_steps(_("Chamfer steps:"), _("Chamfer steps"), "chamfer_steps", &wr, this, 0),
+    
+    helper_size(_("Helper size with direction:"), _("Helper size with direction"), "helper_size", &wr, this, 0)
 {
     registerParameter(&fillet_chamfer_values);
     registerParameter(&unit);
     registerParameter(&method);
     registerParameter(&radius);
+    registerParameter(&chamfer_steps);
     registerParameter(&helper_size);
     registerParameter(&flexible);
     registerParameter(&use_knot_distance);
@@ -81,9 +79,13 @@ LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
     radius.param_set_range(0., infinity());
     radius.param_set_increments(1, 1);
     radius.param_set_digits(4);
+    chamfer_steps.param_set_range(1, 999);
+    chamfer_steps.param_set_increments(1, 1);
+    chamfer_steps.param_set_digits(0);
     helper_size.param_set_range(0, infinity());
     helper_size.param_set_increments(5, 5);
     helper_size.param_set_digits(0);
+    fillet_chamfer_values.set_chamfer_steps(3);
 }
 
 LPEFilletChamfer::~LPEFilletChamfer() {}
@@ -112,6 +114,16 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
                     Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
                     entryWidg->set_width_chars(6);
                 }
+            } else if (param->param_key == "chamfer_steps") {
+                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
+                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamferSubdivisions));
+                widg = widgRegistered;
+                if (widg) {
+                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
+                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
+                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
+                    entryWidg->set_width_chars(3);
+                }
             } else if (param->param_key == "flexible") {
                 Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
                 widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
@@ -141,27 +153,26 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
 
         ++it;
     }
-
-    Gtk::HBox *filletButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
+    Gtk::HBox *filletContainer = Gtk::manage(new Gtk::HBox(true, 0));
     Gtk::Button *fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
     fillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
 
-    filletButtonsContainer->pack_start(*fillet, true, true, 2);
-    Gtk::Button *inverse = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
-    inverse->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverse));
-    filletButtonsContainer->pack_start(*inverse, true, true, 2);
-
-    Gtk::HBox *chamferButtonsContainer = Gtk::manage(new Gtk::HBox(true, 0));
+    filletContainer->pack_start(*fillet, true, true, 2);
+    Gtk::Button *inverseFillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
+    inverseFillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseFillet));
+    filletContainer->pack_start(*inverseFillet, true, true, 2);
+    
+    Gtk::HBox *chamferContainer = Gtk::manage(new Gtk::HBox(true, 0));
     Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
     chamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
 
-    chamferButtonsContainer->pack_start(*chamfer, true, true, 2);
-    Gtk::Button *doubleChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Double chamfer"))));
-    doubleChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::doubleChamfer));
-    chamferButtonsContainer->pack_start(*doubleChamfer, true, true, 2);
+    chamferContainer->pack_start(*chamfer, true, true, 2);
+    Gtk::Button *inverseChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse chamfer"))));
+    inverseChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseChamfer));
+    chamferContainer->pack_start(*inverseChamfer, true, true, 2);
 
-    vbox->pack_start(*filletButtonsContainer, true, true, 2);
-    vbox->pack_start(*chamferButtonsContainer, true, true, 2);
+    vbox->pack_start(*filletContainer, true, true, 2);
+    vbox->pack_start(*chamferContainer, true, true, 2);
 
     return vbox;
 }
@@ -212,8 +223,7 @@ void LPEFilletChamfer::updateFillet()
 {
     double power = 0;
     if (!flexible) {
-        Inkscape::Util::Unit const *doc_units = inkscape_active_desktop()->namedview->doc_units;
-        power = Inkscape::Util::Quantity::convert(radius, unit.get_abbreviation(), doc_units->abbr) * -1;
+        power = Inkscape::Util::Quantity::convert(radius, unit.get_abbreviation(), *defaultUnit) * -1;
     } else {
         power = radius;
     }
@@ -227,64 +237,46 @@ void LPEFilletChamfer::fillet()
     doChangeType(path_from_piecewise(pwd2, tolerance), 1);
 }
 
-void LPEFilletChamfer::inverse()
+void LPEFilletChamfer::inverseFillet()
 {
     Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
     doChangeType(path_from_piecewise(pwd2, tolerance), 2);
 }
 
+void LPEFilletChamfer::chamferSubdivisions()
+{
+    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
+    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
+    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 5000);
+}
+
 void LPEFilletChamfer::chamfer()
 {
+    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
     Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), 3);
+    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 3000);
 }
 
-void LPEFilletChamfer::doubleChamfer()
+void LPEFilletChamfer::inverseChamfer()
 {
+    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
     Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), 4);
+    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 4000);
 }
 
 void LPEFilletChamfer::refreshKnots()
 {
     Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
     fillet_chamfer_values.recalculate_knots(pwd2);
-    SPDesktop *desktop = inkscape_active_desktop();
+    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
     if (tools_isactive(desktop, TOOLS_NODES)) {
         tools_switch(desktop, TOOLS_SELECT);
         tools_switch(desktop, TOOLS_NODES);
     }
 }
 
-bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> point)
-{
-    if (point.size() > 0) {
-        for (std::vector<Geom::Point>::iterator i = point.begin(); i != point.end();
-                ++i) {
-            Geom::Point p = *i;
-            if (Geom::are_near(p, nodePoint, 2)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
 void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power)
 {
-    std::vector<Geom::Point> point;
-    SPDesktop *desktop = inkscape_active_desktop();
-    if (INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nodeTool = INK_NODE_TOOL(desktop->event_context);
-        Inkscape::UI::ControlPointSelection::Set &selection = nodeTool->_selected_nodes->allPoints();
-        std::vector<Geom::Point>::iterator pBegin;
-        for (Inkscape::UI::ControlPointSelection::Set::iterator i = selection.begin(); i != selection.end(); ++i) {
-            if ((*i)->selected()) {
-                Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
-                pBegin = point.begin();
-                point.insert(pBegin, desktop->doc2dt(n->position()));
-            }
-        }
-    }
     std::vector<Point> filletChamferData = fillet_chamfer_values.data();
     std::vector<Geom::Point> result;
     std::vector<Geom::Path> original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
@@ -319,7 +311,7 @@ void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> const& original_pa
             if (filletChamferData[counter][Y] == 0) {
                 powerend = filletChamferData[counter][X];
             }
-            if (only_selected && !nodeIsSelected(curve_it1->initialPoint(), point)) {
+            if (only_selected && !isNodePointSelected(curve_it1->initialPoint())) {
                 powerend = filletChamferData[counter][X];
             }
             result.push_back(Point(powerend, filletChamferData[counter][Y]));
@@ -333,24 +325,6 @@ void LPEFilletChamfer::doUpdateFillet(std::vector<Geom::Path> const& original_pa
 
 void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> const& original_pathv, int type)
 {
-    std::vector<Geom::Point> point;
-    SPDesktop *desktop = inkscape_active_desktop();
-    if (INK_IS_NODE_TOOL(desktop->event_context)) {
-        Inkscape::UI::Tools::NodeTool *nodeTool =
-            INK_NODE_TOOL(desktop->event_context);
-        Inkscape::UI::ControlPointSelection::Set &selection =
-            nodeTool->_selected_nodes->allPoints();
-        std::vector<Geom::Point>::iterator pBegin;
-        for (Inkscape::UI::ControlPointSelection::Set::iterator i =
-                    selection.begin();
-                i != selection.end(); ++i) {
-            if ((*i)->selected()) {
-                Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
-                pBegin = point.begin();
-                point.insert(pBegin, desktop->doc2dt(n->position()));
-            }
-        }
-    }
     std::vector<Point> filletChamferData = fillet_chamfer_values.data();
     std::vector<Geom::Point> result;
     std::vector<Geom::Path> original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
@@ -373,12 +347,18 @@ void LPEFilletChamfer::doChangeType(std::vector<Geom::Path> const& original_path
             bool toggle = true;
             if (filletChamferData[counter][Y] == 0 ||
                     (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
-                                         filletChamferData[counter][X] == counter)) ||
-                    (only_selected &&
-                     !nodeIsSelected(curve_it1->initialPoint(), point))) {
+                    filletChamferData[counter][X] == counter)) ||
+                    (only_selected && !isNodePointSelected(curve_it1->initialPoint()))) {
                 toggle = false;
             }
             if (toggle) {
+                if(type >= 5000){
+                    if(filletChamferData[counter][Y] >= 3000 && filletChamferData[counter][Y] < 4000){
+                        type = type - 2000;
+                    } else if (filletChamferData[counter][Y] >= 4000 && filletChamferData[counter][Y] < 5000){
+                        type = type - 1000;
+                    }
+                }
                 result.push_back(Point(filletChamferData[counter][X], type));
             } else {
                 result.push_back(filletChamferData[counter]);
@@ -451,6 +431,8 @@ void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
         fillet_chamfer_values.param_set_and_write_new_value(point);
     } else {
         g_warning("LPE Fillet can only be applied to shapes (not groups).");
+        SPLPEItem * item = const_cast<SPLPEItem*>(lpeItem);
+        item->removeCurrentPathEffect(false);
     }
 }
 
@@ -462,6 +444,7 @@ void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
         } else {
             fillet_chamfer_values.set_helper_size(helper_size);
         }
+        fillet_chamfer_values.set_document_unit(defaultUnit);
         fillet_chamfer_values.set_use_distance(use_knot_distance);
         fillet_chamfer_values.set_unit(unit.get_abbreviation());
         SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)
@@ -597,11 +580,37 @@ LPEFilletChamfer::doEffect_path(std::vector<Geom::Path> const &path_in)
                 } else {
                     type = std::abs(filletChamferData[counter + 1][Y]);
                 }
-                if (type == 3 || type == 4) {
-                    if (type == 4) {
-                        Geom::Point central = middle_point(startArcPoint, endArcPoint);
-                        LineSegment chamferCenter(central, curve_it1->finalPoint());
-                        path_out.appendNew<Geom::LineSegment>(chamferCenter.pointAt(0.5));
+                if(are_near(middle_point(startArcPoint,endArcPoint),curve_it1->finalPoint(), 0.0001)){
+                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
+                } else if (type >= 3000 && type < 4000) {
+                    unsigned int chamferSubs = type-3000;
+                    Geom::Path path_chamfer;
+                    path_chamfer.start(path_out.finalPoint());
+                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
+                        path_chamfer.appendNew<SVGEllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
+                    } else {
+                        path_chamfer.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
+                    }
+                    double chamfer_stepsTime = 1.0/chamferSubs;
+                    for(unsigned int i = 1; i < chamferSubs; i++){
+                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
+                        path_out.appendNew<Geom::LineSegment>(chamferStep);
+                    }
+                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
+                } else if (type >= 4000 && type < 5000) {
+                    unsigned int chamferSubs = type-4000;
+                    Geom::Path path_chamfer;
+                    path_chamfer.start(path_out.finalPoint());
+                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
+                        ccwToggle = ccwToggle?0:1;
+                        path_chamfer.appendNew<SVGEllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
+                    }else{
+                        path_chamfer.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
+                    }
+                    double chamfer_stepsTime = 1.0/chamferSubs;
+                    for(unsigned int i = 1; i < chamferSubs; i++){
+                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
+                        path_out.appendNew<Geom::LineSegment>(chamferStep);
                     }
                     path_out.appendNew<Geom::LineSegment>(endArcPoint);
                 } else if (type == 2) {
@@ -611,7 +620,7 @@ LPEFilletChamfer::doEffect_path(std::vector<Geom::Path> const &path_in)
                     }else{
                         path_out.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
                     }
-                } else {
+                } else if (type == 1){
                     if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
                         path_out.appendNew<SVGEllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
                     } else {
diff --git a/src/live_effects/lpe-fillet-chamfer.h b/src/live_effects/lpe-fillet-chamfer.h
index 873684101..0d6a1ff17 100644
--- a/src/live_effects/lpe-fillet-chamfer.h
+++ b/src/live_effects/lpe-fillet-chamfer.h
@@ -56,13 +56,13 @@ public:
     void toggleHide();
     void toggleFlexFixed();
     void chamfer();
+    void chamferSubdivisions();
+    void inverseChamfer();
     void fillet();
-    void doubleChamfer();
-    void inverse();
+    void inverseFillet();
     void updateFillet();
     void doUpdateFillet(std::vector<Geom::Path> const& original_pathv, double power);
     void doChangeType(std::vector<Geom::Path> const& original_pathv, int type);
-    bool nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> points);
     void refreshKnots();
 
     FilletChamferPointArrayParam fillet_chamfer_values;
@@ -77,6 +77,7 @@ private:
     UnitParam unit;
     EnumParam<FilletMethod> method;
     ScalarParam radius;
+    ScalarParam chamfer_steps;
     ScalarParam helper_size;
 
     LPEFilletChamfer(const LPEFilletChamfer &);
diff --git a/src/live_effects/lpe-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp
index 8fadd79ed..e1cd91340 100644
--- a/src/live_effects/lpe-lattice2.cpp
+++ b/src/live_effects/lpe-lattice2.cpp
@@ -394,7 +394,7 @@ LPELattice2::resetGrid()
     grid_point32x33x34x35.param_set_and_write_default();
     //todo:this hack is only to reposition the knots on reser grid button
     //Better update path effect in LPEITEM
-    SPDesktop * desktop = inkscape_active_desktop();
+    SPDesktop * desktop = SP_ACTIVE_DESKTOP;
     tools_switch(desktop, TOOLS_SELECT);
     tools_switch(desktop, TOOLS_NODES);
 }
diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp
index 4d8c79198..b5ef26e2f 100644
--- a/src/live_effects/lpe-perspective-envelope.cpp
+++ b/src/live_effects/lpe-perspective-envelope.cpp
@@ -193,8 +193,8 @@ LPEPerspectiveEnvelope::project_point(Geom::Point p){
     double height = boundingbox_Y.extent();
     double delta_x = boundingbox_X.min() - p[X];
     double delta_y = boundingbox_Y.max() - p[Y];
-    Geom::Coord xratio = (delta_x * sgn(delta_x)) / width;
-    Geom::Coord yratio = (delta_y * sgn(delta_y)) / height;
+    Geom::Coord xratio = (delta_x * -1) / width;
+    Geom::Coord yratio = delta_y / height;
     Geom::Line* horiz = new Geom::Line();
     Geom::Line* vert = new Geom::Line();
     vert->setPoints (pointAtRatio(yratio,Down_Left_Point,Up_Left_Point),pointAtRatio(yratio,Down_Right_Point,Up_Right_Point));
@@ -337,7 +337,7 @@ LPEPerspectiveEnvelope::resetGrid()
     Down_Left_Point.param_set_and_write_default();
     //todo:this hack is only to reposition the knots on reser grid button
     //Better update path effect in LPEITEM
-    SPDesktop * desktop = inkscape_active_desktop();
+    SPDesktop * desktop = SP_ACTIVE_DESKTOP;
     tools_switch(desktop, TOOLS_SELECT);
     tools_switch(desktop, TOOLS_NODES);
 }
diff --git a/src/live_effects/lpe-perspective_path.cpp b/src/live_effects/lpe-perspective_path.cpp
index d43772cf7..901519b4f 100644
--- a/src/live_effects/lpe-perspective_path.cpp
+++ b/src/live_effects/lpe-perspective_path.cpp
@@ -23,7 +23,7 @@
 #include "knot-holder-entity.h"
 #include "knotholder.h"
 #include "desktop.h"
-
+#include <util/units.h>
 #include "inkscape.h"
 
 #include <2geom/path.h>
@@ -44,6 +44,8 @@ public:
 } // namespace PP
 
 static Glib::ustring perspectiveID = _("First perspective");
+
+
 LPEPerspectivePath::LPEPerspectivePath(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
     // initialise your parameters here:
@@ -62,35 +64,42 @@ LPEPerspectivePath::LPEPerspectivePath(LivePathEffectObject *lpeobject) :
 
     concatenate_before_pwd2 = true; // don't split the path into its subpaths
     _provides_knotholder_entities = true;
-    unapply = false;
-    Persp3D *persp = persp3d_document_first_persp(lpeobject->document);
+}
+
+LPEPerspectivePath::~LPEPerspectivePath()
+{
+
+}
+void
+LPEPerspectivePath::doOnApply(SPLPEItem const* lpeitem)
+{
+    Persp3D *persp = persp3d_document_first_persp(lpeitem->document);
     if(persp == 0 ){
         char *msg = _("You need a BOX 3D object");
         Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_INFO,
                                   Gtk::BUTTONS_OK, true);
         dialog.run();
-        unapply = true;
-        return;
+        SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+        item->removeCurrentPathEffect(false);
     }
-    Proj::TransfMat3x4 pmat = persp->perspective_impl->tmat;
-    pmat = pmat * SP_ACTIVE_DESKTOP->doc2dt();
-    pmat.copy_tmat(tmat);
 }
-
-LPEPerspectivePath::~LPEPerspectivePath()
-{
-
-}
-
 void
 LPEPerspectivePath::doBeforeEffect (SPLPEItem const* lpeitem)
 {
     original_bbox(lpeitem, true);
-    if(unapply){
-        SP_LPE_ITEM(lpeitem)->removeCurrentPathEffect(false);
+    SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+    Persp3D *persp = persp3d_document_first_persp(lpeitem->document);
+    if(persp == 0 ){
+        char *msg = _("You need a BOX 3D object");
+        Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_INFO,
+                                  Gtk::BUTTONS_OK, true);
+        dialog.run();
         return;
     }
-    SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
+    Proj::TransfMat3x4 pmat = persp->perspective_impl->tmat;
+    Geom::Affine doc2d = Geom::Scale(1, -1) * Geom::Translate(0, item->document->getHeight().value("px"));
+    pmat = pmat * doc2d;
+    pmat.copy_tmat(tmat);
     item->apply_to_clippath(item);
     item->apply_to_mask(item);
 }
diff --git a/src/live_effects/lpe-perspective_path.h b/src/live_effects/lpe-perspective_path.h
index 6ccac4a51..c4ddf1853 100644
--- a/src/live_effects/lpe-perspective_path.h
+++ b/src/live_effects/lpe-perspective_path.h
@@ -33,9 +33,8 @@ class LPEPerspectivePath : public Effect, GroupBBoxEffect {
 public:
     LPEPerspectivePath(LivePathEffectObject *lpeobject);
     virtual ~LPEPerspectivePath();
-    
     virtual void doBeforeEffect (SPLPEItem const* lpeitem);
-
+    virtual void doOnApply(SPLPEItem const* lpeitem);
     virtual Geom::Piecewise<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
 
     virtual void refresh(Gtk::Entry* perspective);
@@ -53,8 +52,6 @@ private:
     ScalarParam offsety;
     BoolParam uses_plane_xy;
     // there are all kinds of parameters. Check the /live_effects/parameter directory which types exist!
-
-    bool unapply;
     Geom::Point orig;
 
     LPEPerspectivePath(const LPEPerspectivePath&);
diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp
index 03a10807a..f7fe9592d 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -277,7 +277,7 @@ LPEPowerStroke::doOnApply(SPLPEItem const* lpeitem)
         double width = (lpeitem && lpeitem->style) ? lpeitem->style->stroke_width.computed / 2 : 1.;
         
         SPCSSAttr *css = sp_repr_css_attr_new ();
-        if (true) {
+        if (lpeitem->style) {
             if (lpeitem->style->stroke.isPaintserver()) {
                 SPPaintServer * server = lpeitem->style->getStrokePaintServer();
                 if (server) {
diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index ffd5433bf..8cef9a3a3 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -14,12 +14,13 @@
  */
 
 #include <gtkmm.h>
-
+#include "desktop.h"
 #include "live_effects/lpe-roughen.h"
 #include "display/curve.h"
 #include "live_effects/parameter/parameter.h"
 #include "helper/geom.h"
 #include <glibmm/i18n.h>
+#include <util/units.h>
 #include <cmath>
 
 namespace Inkscape {
@@ -46,6 +47,8 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
                 "displaceX", &wr, this, 10.),
       displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"),
                 "displaceY", &wr, this, 10.),
+      globalRandomize(_("Global randomize"), _("Global randomize"),
+                     "globalRandomize", &wr, this, 1.),
       shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this,
                  true),
       shiftNodeHandles(_("Shift node handles"), _("Shift node handles"),
@@ -57,10 +60,12 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
     registerParameter(&segments);
     registerParameter(&displaceX);
     registerParameter(&displaceY);
+    registerParameter(&globalRandomize);
     registerParameter(&shiftNodes);
     registerParameter(&shiftNodeHandles);
     displaceX.param_set_range(0., Geom::infinity());
     displaceY.param_set_range(0., Geom::infinity());
+    globalRandomize.param_set_range(0., Geom::infinity());
     maxSegmentSize.param_set_range(0., Geom::infinity());
     maxSegmentSize.param_set_increments(1, 1);
     maxSegmentSize.param_set_digits(1);
@@ -75,6 +80,7 @@ void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem)
 {
     displaceX.resetRandomizer();
     displaceY.resetRandomizer();
+    globalRandomize.resetRandomizer();
     srand(1);
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
     item->apply_to_clippath(item);
@@ -118,6 +124,15 @@ Gtk::Widget *LPERoughen::newWidget()
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
+            if (param->param_key == "globalRandomize") {
+                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+                                                 Glib::ustring(_("<b>Extra roughen</b> Add a extra layer of rough")),
+                                                 Gtk::ALIGN_START));
+                displaceXLabel->set_use_markup(true);
+                vbox->pack_start(*displaceXLabel, false, false, 2);
+                vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
+                                 Gtk::PACK_EXPAND_WIDGET);
+            }
             Glib::ustring *tip = param->param_getTooltip();
             if (widg) {
                 vbox->pack_start(*widg, true, true, 2);
@@ -145,10 +160,11 @@ double LPERoughen::sign(double randNumber)
 
 Geom::Point LPERoughen::randomize()
 {
+    Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units;
     double displaceXParsed = Inkscape::Util::Quantity::convert(
-                                 displaceX, unit.get_abbreviation(), "px");
+                                 displaceX * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
     double displaceYParsed = Inkscape::Util::Quantity::convert(
-                                 displaceY, unit.get_abbreviation(), "px");
+                                 displaceY * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
 
     Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed));
     return output;
@@ -159,6 +175,7 @@ void LPERoughen::doEffect(SPCurve *curve)
     Geom::PathVector const original_pathv =
         pathv_to_linear_and_cubic_beziers(curve->get_pathvector());
     curve->reset();
+    Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units;
     for (Geom::PathVector::const_iterator path_it = original_pathv.begin();
             path_it != original_pathv.end(); ++path_it) {
         if (path_it->empty())
@@ -185,6 +202,7 @@ void LPERoughen::doEffect(SPCurve *curve)
         Geom::Point A1(0, 0);
         Geom::Point A2(0, 0);
         Geom::Point A3(0, 0);
+        bool first = true;
         while (curve_it1 != curve_endit) {
             Geom::CubicBezier const *cubic = NULL;
             A0 = curve_it1->initialPoint();
@@ -194,7 +212,7 @@ void LPERoughen::doEffect(SPCurve *curve)
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
             if (cubic) {
                 A1 = (*cubic)[1];
-                if (shiftNodes) {
+                if (shiftNodes && first) {
                     A1 = (*cubic)[1] + initialMove;
                 }
                 A2 = (*cubic)[2];
@@ -203,7 +221,7 @@ void LPERoughen::doEffect(SPCurve *curve)
                 nCurve->lineto(A3);
             }
             double length = Inkscape::Util::Quantity::convert(
-                                curve_it1->length(0.001), "px", unit.get_abbreviation());
+                                curve_it1->length(0.001), svg_units->abbr, unit.get_abbreviation());
             std::size_t splits = 0;
             if (method == DM_SEGMENTS) {
                 splits = segments;
@@ -232,6 +250,7 @@ void LPERoughen::doEffect(SPCurve *curve)
             if(curve_it2 != curve_endit) {
                 ++curve_it2;
             }
+            first = false;
         }
         if (path_it->closed()) {
             nCurve->closepath_current();
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index d5ec726bd..74331f1ef 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -51,8 +51,10 @@ private:
     ScalarParam segments;
     RandomParam displaceX;
     RandomParam displaceY;
+    RandomParam globalRandomize;
     BoolParam shiftNodes;
     BoolParam shiftNodeHandles;
+
     LPERoughen(const LPERoughen &);
     LPERoughen &operator=(const LPERoughen &);
 
diff --git a/src/live_effects/lpe-show_handles.cpp b/src/live_effects/lpe-show_handles.cpp
index 7b2b445b7..2d8148730 100644
--- a/src/live_effects/lpe-show_handles.cpp
+++ b/src/live_effects/lpe-show_handles.cpp
@@ -25,15 +25,20 @@ LPEShowHandles::LPEShowHandles(LivePathEffectObject *lpeobject)
       nodes(_("Show nodes"), _("Show nodes"), "nodes", &wr, this, true),
       handles(_("Show handles"), _("Show handles"), "handles", &wr, this, true),
       originalPath(_("Show path"), _("Show path"), "originalPath", &wr, this, true),
-      scaleNodesAndHandles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scaleNodesAndHandles", &wr, this, 10)
+      scaleNodesAndHandles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scaleNodesAndHandles", &wr, this, 10),
+      rotateNodes(_("Rotate nodes"), _("Rotate nodes"), "rotateNodes", &wr, this, 0)
 {
     registerParameter(dynamic_cast<Parameter *>(&nodes));
     registerParameter(dynamic_cast<Parameter *>(&handles));
     registerParameter(dynamic_cast<Parameter *>(&originalPath));
     registerParameter(dynamic_cast<Parameter *>(&scaleNodesAndHandles));
+    registerParameter(dynamic_cast<Parameter *>(&rotateNodes));
     scaleNodesAndHandles.param_set_range(0, 500.);
     scaleNodesAndHandles.param_set_increments(1, 1);
     scaleNodesAndHandles.param_set_digits(2);
+    rotateNodes.param_set_range(0, 365);
+    rotateNodes.param_set_increments(1, 1);
+    rotateNodes.param_set_digits(0);
     strokeWidth = 1.0;
 }
 
@@ -158,10 +163,11 @@ LPEShowHandles::drawNode(Geom::Point p)
     if(strokeWidth * scaleNodesAndHandles > 0.0) {
         double diameter = strokeWidth * scaleNodesAndHandles;
         char const * svgd;
-        svgd = "M 0.55,0.5 A 0.05,0.05 0 0 1 0.5,0.55 0.05,0.05 0 0 1 0.45,0.5 0.05,0.05 0 0 1 0.5,0.45 0.05,0.05 0 0 1 0.55,0.5 Z M 0,0 1,0 1,1 0,1 Z";
+        svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z";
         Geom::PathVector pathv = sp_svg_read_pathv(svgd);
-        pathv *= Geom::Affine(diameter,0,0,diameter,0,0);
-        pathv += p - Geom::Point(diameter/2,diameter/2);
+        pathv *= Geom::Rotate::from_degrees(rotateNodes);
+        pathv *= Geom::Scale (diameter);
+        pathv += p;
         outlinepath.push_back(pathv[0]);
         outlinepath.push_back(pathv[1]);
     }
@@ -175,8 +181,8 @@ LPEShowHandles::drawHandle(Geom::Point p)
         char const * svgd;
         svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z";
         Geom::PathVector pathv = sp_svg_read_pathv(svgd);
-        pathv *= Geom::Affine(diameter,0,0,diameter,0,0);
-        pathv += p - Geom::Point(diameter * 0.35,diameter * 0.35);
+        pathv *= Geom::Scale (diameter);
+        pathv += p-Geom::Point(diameter * 0.35,diameter * 0.35);
         outlinepath.push_back(pathv[0]);
     }
 }
diff --git a/src/live_effects/lpe-show_handles.h b/src/live_effects/lpe-show_handles.h
index 278908bb5..a405c26ee 100644
--- a/src/live_effects/lpe-show_handles.h
+++ b/src/live_effects/lpe-show_handles.h
@@ -44,6 +44,7 @@ private:
     BoolParam handles;
     BoolParam originalPath;
     ScalarParam scaleNodesAndHandles;
+    ScalarParam rotateNodes;
     double strokeWidth;
     static bool alertsOff;
 
diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp
index c191fbbe6..2b2efb1a9 100644
--- a/src/live_effects/lpe-simplify.cpp
+++ b/src/live_effects/lpe-simplify.cpp
@@ -157,8 +157,8 @@ LPESimplify::doEffect(SPCurve *curve) {
     Geom::PathVector outres = Geom::parse_svg_path(pathliv->svg_dump_path());
     generateHelperPath(outres);
     curve->set_pathvector(outres);
-    if(SP_ACTIVE_DESKTOP && INK_IS_NODE_TOOL(SP_ACTIVE_DESKTOP->event_context)){
-        SPDesktop* desktop = SP_ACTIVE_DESKTOP;
+    SPDesktop* desktop = SP_ACTIVE_DESKTOP;
+    if(desktop && INK_IS_NODE_TOOL(desktop->event_context)){
         Inkscape::UI::Tools::NodeTool *nt = static_cast<Inkscape::UI::Tools::NodeTool*>(desktop->event_context);
         nt->update_helperpath();
     }
diff --git a/src/live_effects/lpe-taperstroke.cpp b/src/live_effects/lpe-taperstroke.cpp
index b595b8d55..7a024147c 100644
--- a/src/live_effects/lpe-taperstroke.cpp
+++ b/src/live_effects/lpe-taperstroke.cpp
@@ -71,12 +71,12 @@ static const Util::EnumDataConverter<unsigned> JoinTypeConverter(JoinType, sizeo
 
 LPETaperStroke::LPETaperStroke(LivePathEffectObject *lpeobject) :
     Effect(lpeobject),
-    line_width(_("Stroke width"), _("The (non-tapered) width of the path"), "stroke_width", &wr, this, 1.),
-    attach_start(_("Start offset"), _("Taper distance from path start"), "attach_start", &wr, this, 0.2),
-    attach_end(_("End offset"), _("The ending position of the taper"), "end_offset", &wr, this, 0.2),
-    smoothing(_("Taper smoothing"), _("Amount of smoothing to apply to the tapers"), "smoothing", &wr, this, 0.5),
-    join_type(_("Join type"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED),
-    miter_limit(_("Miter limit"), _("Limit for miter joins"), "miter_limit", &wr, this, 100.)
+    line_width(_("Stroke width:"), _("The (non-tapered) width of the path"), "stroke_width", &wr, this, 1.),
+    attach_start(_("Start offset:"), _("Taper distance from path start"), "attach_start", &wr, this, 0.2),
+    attach_end(_("End offset:"), _("The ending position of the taper"), "end_offset", &wr, this, 0.2),
+    smoothing(_("Taper smoothing:"), _("Amount of smoothing to apply to the tapers"), "smoothing", &wr, this, 0.5),
+    join_type(_("Join type:"), _("Join type for non-smooth nodes"), "jointype", JoinTypeConverter, &wr, this, LINEJOIN_EXTRAPOLATED),
+    miter_limit(_("Miter limit:"), _("Limit for miter joins"), "miter_limit", &wr, this, 100.)
 {
     show_orig_path = true;
     _provides_knotholder_entities = true;
diff --git a/src/live_effects/parameter/filletchamferpointarray.cpp b/src/live_effects/parameter/filletchamferpointarray.cpp
index db24a9735..2ebe11b4b 100644
--- a/src/live_effects/parameter/filletchamferpointarray.cpp
+++ b/src/live_effects/parameter/filletchamferpointarray.cpp
@@ -354,11 +354,21 @@ void FilletChamferPointArrayParam::set_pwd2(
     last_pwd2_normal = pwd2_normal_in;
 }
 
+void FilletChamferPointArrayParam::set_document_unit(Glib::ustring const * value_document_unit)
+{
+    documentUnit = value_document_unit;
+}
+
 void FilletChamferPointArrayParam::set_helper_size(int hs)
 {
     helper_size = hs;
 }
 
+void FilletChamferPointArrayParam::set_chamfer_steps(int value_chamfer_steps)
+{
+    chamfer_steps = value_chamfer_steps;
+}
+
 void FilletChamferPointArrayParam::set_use_distance(bool use_knot_distance )
 {
     use_distance = use_knot_distance;
@@ -683,28 +693,6 @@ void FilletChamferPointArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
     knot_mode = mode;
     knot_color = color;
 }
-/*
-class FilletChamferPointArrayParamKnotHolderEntity : public KnotHolderEntity {
-public:
-    FilletChamferPointArrayParamKnotHolderEntity(FilletChamferPointArrayParam
-*p, unsigned int index);
-    virtual ~FilletChamferPointArrayParamKnotHolderEntity() {}
-
-    virtual void knot_set(Point const &p, Point const &origin, guint state);
-    virtual Point knot_get() const;
-    virtual void knot_click(guint state);
-    virtual void knot_doubleclicked(guint state);
-
-    /Checks whether the index falls within the size of the parameter's vector/
-    bool valid_index(unsigned int index) const {
-        return (_pparam->_vector.size() > index);
-    };
-
-private:
-    FilletChamferPointArrayParam *_pparam;
-    unsigned int _index;
-};
-/*/
 
 FilletChamferPointArrayParamKnotHolderEntity::
 FilletChamferPointArrayParamKnotHolderEntity(
@@ -712,19 +700,18 @@ FilletChamferPointArrayParamKnotHolderEntity(
     : _pparam(p), _index(index) {}
 
 void FilletChamferPointArrayParamKnotHolderEntity::knot_set(Point const &p,
-        Point const &origin,
-        guint state)
+                                                            Point const &/*origin*/,
+                                                            guint state)
 {
     using namespace Geom;
 
     if (!valid_index(_index)) {
         return;
     }
-    /// @todo how about item transforms???
     Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
-    //todo: add snapping
-    //Geom::Point const s = snap_knot_position(p, state);
     double t = nearest_point(p, pwd2[_index]);
+    Geom::Point const s = snap_knot_position(pwd2[_index].valueAt(t), state);
+    t = nearest_point(s, pwd2[_index]);
     if (t == 1) {
         t = 0.9999;
     }
@@ -766,28 +753,45 @@ void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
             sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
         }else{
             using namespace Geom;
-            double type = _pparam->_vector.at(_index)[Y] + 1;
-            if (type > 4) {
-                type = 1;
+            int type = (int)_pparam->_vector.at(_index)[Y];
+            if (type >=3000 && type < 4000){
+                type = 3;
             }
-            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], type);
+            if (type >=4000 && type < 5000){
+                type = 4;
+            }
+            switch(type){
+                case 1:
+                    type = 2;
+                    break;
+                case 2:
+                    type =  _pparam->chamfer_steps + 3000;
+                    break;
+                case 3:
+                    type =  _pparam->chamfer_steps + 4000;
+                    break;
+                default:
+                    type = 1;
+                    break;
+            }
+            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], (double)type);
             _pparam->param_set_and_write_new_value(_pparam->_vector);
             sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
             const gchar *tip;
-            if (type == 3) {
-                tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+            if (type >=3000 && type < 4000){
+                 tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
-            } else if (type == 2) {
-                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+            } else if (type >=4000 && type < 5000) {
+                tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
-            } else if (type == 1) {
-                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+            } else if (type == 2) {
+                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
             } else {
-                tip = _("<b>Double Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
             }
@@ -809,7 +813,7 @@ void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
         bool aprox = (A[0].degreesOfFreedom() != 2 || B[0].degreesOfFreedom() != 2) && !_pparam->use_distance?true:false;
         Geom::Point offset = Geom::Point(xModified, _pparam->_vector.at(_index).y());
         Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
-            this->desktop, offset, this, _pparam->unit, _pparam->use_distance, aprox);
+            this->desktop, offset, this, _pparam->unit, _pparam->use_distance, aprox, _pparam->documentUnit);
     }
 
 }
@@ -835,20 +839,20 @@ void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
             continue;
         }
         const gchar *tip;
-        if (_vector[i][Y] == 3) {
-            tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+        if (_vector[i][Y] >=3000 && _vector[i][Y] < 4000){
+             tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
                     "<b>Shift+Click</b> open dialog, "
                     "<b>Ctrl+Alt+Click</b> reset");
-        } else if (_vector[i][Y] == 2) {
-            tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+        } else if (_vector[i][Y] >=4000 && _vector[i][Y] < 5000) {
+            tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
                     "<b>Shift+Click</b> open dialog, "
                     "<b>Ctrl+Alt+Click</b> reset");
-        } else if (_vector[i][Y] == 1) {
-            tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle type, "
+        } else if (_vector[i][Y] == 2) {
+            tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
                     "<b>Shift+Click</b> open dialog, "
                     "<b>Ctrl+Alt+Click</b> reset");
         } else {
-            tip = _("<b>Double Chamfer</b>: <b>Ctrl+Click</b> toogle type, "
+            tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
                     "<b>Shift+Click</b> open dialog, "
                     "<b>Ctrl+Alt+Click</b> reset");
         }
diff --git a/src/live_effects/parameter/filletchamferpointarray.h b/src/live_effects/parameter/filletchamferpointarray.h
index a1fa698ae..6e5cce353 100644
--- a/src/live_effects/parameter/filletchamferpointarray.h
+++ b/src/live_effects/parameter/filletchamferpointarray.h
@@ -52,6 +52,8 @@ public:
     std::vector<double> get_times(int index, std::vector<Geom::Path> subpaths, bool last);
     virtual void set_helper_size(int hs);
     virtual void set_use_distance(bool use_knot_distance);
+    virtual void set_chamfer_steps(int value_chamfer_steps);
+    virtual void set_document_unit(Glib::ustring const * value_document_unit);
     virtual void set_unit(const gchar *abbr);
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
                                      std::vector<Geom::PathVector> &hp_vec);
@@ -85,8 +87,10 @@ private:
     SPKnotModeType knot_mode;
     guint32 knot_color;
     int helper_size;
+    int chamfer_steps;
     bool use_distance;
     const gchar *unit;
+    Glib::ustring const * documentUnit;
     Geom::PathVector hp;
 
     Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2;
diff --git a/src/live_effects/parameter/originalpath.cpp b/src/live_effects/parameter/originalpath.cpp
index 6c4f2a100..0884c4c9c 100644
--- a/src/live_effects/parameter/originalpath.cpp
+++ b/src/live_effects/parameter/originalpath.cpp
@@ -27,7 +27,7 @@
 #include "live_effects/effect.h"
 
 #include "inkscape.h"
-#include "desktop-handles.h"
+#include "desktop.h"
 #include "selection.h"
 #include "ui/icon-names.h"
 
@@ -128,7 +128,7 @@ OriginalPathParam::on_select_original_button_click()
     if (desktop == NULL || original == NULL) {
         return;
     }
-    Inkscape::Selection *selection = sp_desktop_selection(desktop);
+    Inkscape::Selection *selection = desktop->getSelection();
     selection->clear();
     selection->set(original);
 }
diff --git a/src/live_effects/parameter/parameter.cpp b/src/live_effects/parameter/parameter.cpp
index 7a2fd9769..beb750404 100644
--- a/src/live_effects/parameter/parameter.cpp
+++ b/src/live_effects/parameter/parameter.cpp
@@ -47,7 +47,7 @@ Parameter::param_write_to_repr(const char * svgd)
 // in gtk3, it is an issue: it allocates widget size for the maxmium
 // value you pass to it, leading to some insane lengths.
 // If you need this to be more, please be conservative about it.
-const double SCALARPARAM_G_MAXDOUBLE = 10000000000;
+const double SCALARPARAM_G_MAXDOUBLE = 10000000000.0; // TODO fixme: using an arbitrary large number as a magic value seems fragile.
 
 void Parameter::write_to_SVG(void)
 {
diff --git a/src/live_effects/parameter/path.cpp b/src/live_effects/parameter/path.cpp
index 2a14d4208..ba95affd9 100644
--- a/src/live_effects/parameter/path.cpp
+++ b/src/live_effects/parameter/path.cpp
@@ -30,7 +30,7 @@
 // needed for on-canvas editting:
 #include "ui/tools-switch.h"
 #include "ui/shape-editor.h"
-#include "desktop-handles.h"
+
 #include "selection.h"
 // clipboard support
 #include "ui/clipboard.h"
@@ -414,7 +414,7 @@ PathParam::linked_modified_callback(SPObject *linked_obj, guint /*flags*/)
 void
 PathParam::on_edit_button_click()
 {
-    SPItem * item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->singleItem();
+    SPItem * item = SP_ACTIVE_DESKTOP->getSelection()->singleItem();
     if (item != NULL) {
         param_editOncanvas(item, SP_ACTIVE_DESKTOP);
     }
diff --git a/src/live_effects/parameter/text.cpp b/src/live_effects/parameter/text.cpp
index 956a001ad..234a6174d 100644
--- a/src/live_effects/parameter/text.cpp
+++ b/src/live_effects/parameter/text.cpp
@@ -19,6 +19,7 @@
 #include "inkscape.h"
 #include "verbs.h"
 #include "display/canvas-text.h"
+
 #include <2geom/sbasis-geometric.h>
 
 namespace Inkscape {
@@ -32,8 +33,8 @@ TextParam::TextParam( const Glib::ustring& label, const Glib::ustring& tip,
       value(default_value),
       defvalue(default_value)
 {
-    SPDesktop *desktop = inkscape_active_desktop(); // FIXME: we shouldn't use this!
-    canvas_text = (SPCanvasText *) sp_canvastext_new(sp_desktop_tempgroup(desktop), desktop, Geom::Point(0,0), "");
+    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);
 }