Refactor to remove references to Desktop/Ui in Effect, bspline and fillet-chamfer.

Also fixed the selected node problem in units not px.
Also fixed two var to not allow NULL pointed by Johan Engelen.

(bzr r13672)

9 files changed, 106 insertions, 219 deletions

diff --git a/src/live_effects/effect.cpp b/src/live_effects/effect.cpp
index 1a64defd9..fbdc78f8a 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,36 @@ 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) {
+        for (std::vector<Geom::Point>::const_iterator i = selectedNodesPoints.begin();
+                i != selectedNodesPoints.end(); ++i) {
+            Geom::Point p = *i;
+            std::cout << p << "p\n";
+            p[Geom::X] = Inkscape::Util::Quantity::convert(p[Geom::X], "px", *defaultUnit);
+            p[Geom::Y] = Inkscape::Util::Quantity::convert(p[Geom::Y], "px", *defaultUnit);
+            if (Geom::are_near(p, nodePoint, 0.01)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 /**
  * Is performed each time before the effect is updated.
  */
@@ -419,6 +448,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->getDefaultUnit()->abbr;
     /*sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
     pathvector_before_effect = sp_curve->get_pathvector();*/
     doOnApply(lpeitem);
@@ -427,6 +457,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->getDefaultUnit()->abbr;
     //printf("(SPLPEITEM*) %p\n", sp_lpe_item);
     sp_curve = SP_SHAPE(sp_lpe_item)->getCurve();
     pathvector_before_effect = sp_curve->get_pathvector();
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 eb492b821..97a4c6205 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;
 
@@ -127,11 +120,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 /= desktop->current_zoom();
-        radiusHelperNodes = Inkscape::Util::Quantity::convert(radiusHelperNodes, "px", desktop->namedview->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())
@@ -164,16 +154,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());
@@ -259,10 +241,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]))) {
@@ -273,12 +252,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;
         }
@@ -292,7 +265,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]);
     }
 }
 
@@ -313,7 +286,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
@@ -331,12 +303,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);
             }
@@ -380,24 +352,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()
@@ -407,92 +369,33 @@ void LPEBSpline::toWeight()
 
 void LPEBSpline::changeWeight(double weightValue)
 {
-    SPDesktop *desktop = SP_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, std::vector<Geom::Point> selectedPoints)
-{
-    using Geom::X;
-    using Geom::Y;
-
-    if (selectedPoints.size() > 0) {
-        for (std::vector<Geom::Point>::iterator i = selectedPoints.begin();
-                i != selectedPoints.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 = SP_ACTIVE_DESKTOP;
-    std::vector<Geom::Point> selectedPoints;
-    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();
-        selectedPoints.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 = selectedPoints.begin();
-                selectedPoints.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 +418,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 +467,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
             } else {
                 if (cubic) {
                     if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) {
-                        if (nodeIsSelected(pointAt0, selectedPoints)) {
+                        if (isNodePointSelected(pointAt0)) {
                             pointAt1 = SBasisIn.valueAt(weightValue);
                             if (weightValue != noPower) {
                                 pointAt1 =
@@ -585,7 +480,7 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                         pointAt1 = in->first_segment()->initialPoint();
                     }
                     if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) {
-                        if (nodeIsSelected(pointAt3, selectedPoints)) {
+                        if (isNodePointSelected(pointAt3)) {
                             pointAt2 = SBasisIn.valueAt(1 - weightValue);
                             if (weightValue != noPower) {
                                 pointAt2 =
@@ -599,14 +494,14 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue)
                     }
                 } else {
                     if (!ignoreCusp && weightValue != noPower) {
-                        if (nodeIsSelected(pointAt0, selectedPoints)) {
+                        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, selectedPoints)) {
+                        if (isNodePointSelected(pointAt3)) {
                             pointAt2 = SBasisIn.valueAt(weightValue);
                             pointAt2 =
                                 Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap);
@@ -621,14 +516,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 +526,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 ca9ae06be..8751a5720 100644
--- a/src/live_effects/lpe-bspline.h
+++ b/src/live_effects/lpe-bspline.h
@@ -26,13 +26,12 @@ public:
     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, std::vector<Geom::Point> selectedPoints);
+    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
diff --git a/src/live_effects/lpe-fillet-chamfer.cpp b/src/live_effects/lpe-fillet-chamfer.cpp
index da6819120..c491ea858 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:
@@ -65,7 +60,7 @@ LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
     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.),
-    chamferSteps(_("Chamfer steps"), _("Chamfer steps"), "chamferSteps", &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)
 {
@@ -73,7 +68,7 @@ LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
     registerParameter(&unit);
     registerParameter(&method);
     registerParameter(&radius);
-    registerParameter(&chamferSteps);
+    registerParameter(&chamfer_steps);
     registerParameter(&helper_size);
     registerParameter(&flexible);
     registerParameter(&use_knot_distance);
@@ -84,12 +79,13 @@ LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
     radius.param_set_range(0., infinity());
     radius.param_set_increments(1, 1);
     radius.param_set_digits(4);
-    chamferSteps.param_set_range(0, infinity());
-    chamferSteps.param_set_increments(1, 1);
-    chamferSteps.param_set_digits(0);
+    chamfer_steps.param_set_range(0, infinity());
+    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() {}
@@ -118,7 +114,7 @@ Gtk::Widget *LPEFilletChamfer::newWidget()
                     Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
                     entryWidg->set_width_chars(6);
                 }
-            } else if (param->param_key == "chamferSteps") {
+            } 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::chamfer));
                 widg = widgRegistered;
@@ -222,8 +218,7 @@ void LPEFilletChamfer::updateFillet()
 {
     double power = 0;
     if (!flexible) {
-        Inkscape::Util::Unit const *doc_units = SP_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;
     }
@@ -245,9 +240,9 @@ void LPEFilletChamfer::inverse()
 
 void LPEFilletChamfer::chamfer()
 {
+    fillet_chamfer_values.set_chamfer_steps(chamfer_steps + 3);
     Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
-    doChangeType(path_from_piecewise(pwd2, tolerance), chamferSteps + 3);
-    fillet_chamfer_values.set_chamferSteps(chamferSteps + 3);
+    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 3);
 }
 
 void LPEFilletChamfer::refreshKnots()
@@ -261,35 +256,8 @@ void LPEFilletChamfer::refreshKnots()
     }
 }
 
-bool LPEFilletChamfer::nodeIsSelected(Geom::Point nodePoint, std::vector<Geom::Point> selectedPoints)
-{
-    if (selectedPoints.size() > 0) {
-        for (std::vector<Geom::Point>::iterator i = selectedPoints.begin(); i != selectedPoints.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> selectedPoints;
-    SPDesktop *desktop = SP_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 = selectedPoints.begin();
-                selectedPoints.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);
@@ -324,7 +292,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(), selectedPoints)) {
+            if (only_selected && !isNodePointSelected(curve_it1->initialPoint())) {
                 powerend = filletChamferData[counter][X];
             }
             result.push_back(Point(powerend, filletChamferData[counter][Y]));
@@ -338,24 +306,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> selectedPoints;
-    SPDesktop *desktop = SP_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 = selectedPoints.begin();
-                selectedPoints.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);
@@ -378,9 +328,8 @@ 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(), selectedPoints))) {
+                    filletChamferData[counter][X] == counter)) ||
+                    (only_selected && !isNodePointSelected(curve_it1->initialPoint()))) {
                 toggle = false;
             }
             if (toggle) {
@@ -611,9 +560,9 @@ LPEFilletChamfer::doEffect_path(std::vector<Geom::Path> const &path_in)
                     } else {
                         path_chamfer.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
                     }
-                    double chamferStepsTime = 1.0/chamferSubs;
+                    double chamfer_stepsTime = 1.0/chamferSubs;
                     for(unsigned int i = 1; i < chamferSubs; i++){
-                        Geom::Point chamferStep = path_chamfer.pointAt(chamferStepsTime * i);
+                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
                         path_out.appendNew<Geom::LineSegment>(chamferStep);
                     }
                     path_out.appendNew<Geom::LineSegment>(endArcPoint);
diff --git a/src/live_effects/lpe-fillet-chamfer.h b/src/live_effects/lpe-fillet-chamfer.h
index 25e619436..e3589197c 100644
--- a/src/live_effects/lpe-fillet-chamfer.h
+++ b/src/live_effects/lpe-fillet-chamfer.h
@@ -61,7 +61,6 @@ public:
     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> selectedPoints);
     void refreshKnots();
 
     FilletChamferPointArrayParam fillet_chamfer_values;
@@ -76,7 +75,7 @@ private:
     UnitParam unit;
     EnumParam<FilletMethod> method;
     ScalarParam radius;
-    ScalarParam chamferSteps;
+    ScalarParam chamfer_steps;
     ScalarParam helper_size;
 
     LPEFilletChamfer(const LPEFilletChamfer &);
diff --git a/src/live_effects/parameter/filletchamferpointarray.cpp b/src/live_effects/parameter/filletchamferpointarray.cpp
index f43f6108d..31d996ad0 100644
--- a/src/live_effects/parameter/filletchamferpointarray.cpp
+++ b/src/live_effects/parameter/filletchamferpointarray.cpp
@@ -359,9 +359,9 @@ void FilletChamferPointArrayParam::set_helper_size(int hs)
     helper_size = hs;
 }
 
-void FilletChamferPointArrayParam::set_chamferSteps(int chamferSteps)
+void FilletChamferPointArrayParam::set_chamfer_steps(int value_chamfer_steps)
 {
-    chamfer_steps = chamferSteps;
+    chamfer_steps = value_chamfer_steps;
 }
 
 void FilletChamferPointArrayParam::set_use_distance(bool use_knot_distance )
@@ -771,14 +771,20 @@ 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 > 3) {
-                type = 1;
+            int type = (int)_pparam->_vector.at(_index)[Y];
+            
+            switch(type){
+                case 1:
+                    type = 2;
+                    break;
+                case 2:
+                    type =  _pparam->chamfer_steps;
+                    break;
+                default:
+                    type = 1;
+                    break;
             }
-            if (type == 3){
-                type = _pparam->chamfer_steps;
-            }
-            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], type);
+            _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;
@@ -790,7 +796,7 @@ void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
                 tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
-            } else if (type == 1) {
+            } else {
                 tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle type, "
                         "<b>Shift+Click</b> open dialog, "
                         "<b>Ctrl+Alt+Click</b> reset");
@@ -847,7 +853,7 @@ void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
             tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toogle type, "
                     "<b>Shift+Click</b> open dialog, "
                     "<b>Ctrl+Alt+Click</b> reset");
-        } else if (_vector[i][Y] == 1) {
+        } else {
             tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toogle 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 3ef52d11a..1dd31d6d4 100644
--- a/src/live_effects/parameter/filletchamferpointarray.h
+++ b/src/live_effects/parameter/filletchamferpointarray.h
@@ -52,7 +52,7 @@ 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_chamferSteps(int chamferSteps);
+    virtual void set_chamfer_steps(int value_chamfer_steps);
     virtual void set_unit(const gchar *abbr);
     virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
                                      std::vector<Geom::PathVector> &hp_vec);
diff --git a/src/ui/tools/node-tool.cpp b/src/ui/tools/node-tool.cpp
index e2bb85d11..99d60e2b7 100644
--- a/src/ui/tools/node-tool.cpp
+++ b/src/ui/tools/node-tool.cpp
@@ -305,6 +305,16 @@ void  NodeTool::update_helperpath () {
     if (SP_IS_LPE_ITEM(selection->singleItem())) {
         Inkscape::LivePathEffect::Effect *lpe = SP_LPE_ITEM(selection->singleItem())->getCurrentLPE();
         if (lpe && lpe->isVisible()/* && lpe->showOrigPath()*/) {
+            Inkscape::UI::ControlPointSelection::Set &selectionNodes = _selected_nodes->allPoints();
+            std::vector<Geom::Point> selectedNodesPositions;
+            for (Inkscape::UI::ControlPointSelection::Set::iterator i = selectionNodes.begin(); i != selectionNodes.end(); ++i) {
+                if ((*i)->selected()) {
+                    Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
+                    selectedNodesPositions.push_back(desktop->doc2dt(n->position()));
+                }
+            }
+            lpe->setSelectedNodePoints(selectedNodesPositions);
+            lpe->setCurrentZoom(this->desktop->current_zoom());
             SPCurve *c = new SPCurve();
             SPCurve *cc = new SPCurve();
             std::vector<Geom::PathVector> cs = lpe->getCanvasIndicators(SP_LPE_ITEM(selection->singleItem()));