Merge experimental

(bzr r13641)

33 files changed, 1210 insertions, 151 deletions

diff --git a/src/ui/tools/arc-tool.cpp b/src/ui/tools/arc-tool.cpp
index 43f8eb9e1..4f64ade25 100644
--- a/src/ui/tools/arc-tool.cpp
+++ b/src/ui/tools/arc-tool.cpp
@@ -40,7 +40,7 @@
 #include "desktop-style.h"
 #include "context-fns.h"
 #include "verbs.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "ui/tools/tool-base.h"
 
 #include "ui/tools/arc-tool.h"
@@ -48,7 +48,7 @@
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -102,8 +102,8 @@ ArcTool::~ArcTool() {
  * destroys old and creates new knotholder.
  */
 void ArcTool::selection_changed(Inkscape::Selection* selection) {
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 }
 
 void ArcTool::setup() {
@@ -115,7 +115,7 @@ void ArcTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     this->sel_changed_connection.disconnect();
diff --git a/src/ui/tools/arc-tool.h b/src/ui/tools/arc-tool.h
index c4c67660d..55cbaf78c 100644
--- a/src/ui/tools/arc-tool.h
+++ b/src/ui/tools/arc-tool.h
@@ -30,7 +30,7 @@ namespace Inkscape {
 }
 
 #define SP_ARC_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::ArcTool*>((Inkscape::UI::Tools::ToolBase*)obj))
-#define SP_IS_ARC_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::ArcTool*>(const Inkscape::UI::Tools::ToolBase*(obj)) != NULL)
+#define SP_IS_ARC_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::ArcTool*>(obj) != NULL)
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/box3d-tool.cpp b/src/ui/tools/box3d-tool.cpp
index e00894d55..0a20a0842 100644
--- a/src/ui/tools/box3d-tool.cpp
+++ b/src/ui/tools/box3d-tool.cpp
@@ -47,12 +47,12 @@
 #include "box3d-side.h"
 #include "document-private.h"
 #include "line-geometry.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "verbs.h"
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -112,8 +112,8 @@ Box3dTool::~Box3dTool() {
  * destroys old and creates new knotholder.
  */
 void Box3dTool::selection_changed(Inkscape::Selection* selection) {
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 
     if (selection->perspList().size() == 1) {
         // selecting a single box changes the current perspective
@@ -147,7 +147,7 @@ void Box3dTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     this->sel_changed_connection.disconnect();
diff --git a/src/ui/tools/calligraphic-tool.cpp b/src/ui/tools/calligraphic-tool.cpp
index 64097e834..d297fe5e1 100644
--- a/src/ui/tools/calligraphic-tool.cpp
+++ b/src/ui/tools/calligraphic-tool.cpp
@@ -82,7 +82,7 @@ using Inkscape::DocumentUndo;
 
 #define DYNA_MIN_WIDTH 1.0e-6
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/connector-tool.cpp b/src/ui/tools/connector-tool.cpp
index d1355e807..7b5c84c16 100644
--- a/src/ui/tools/connector-tool.cpp
+++ b/src/ui/tools/connector-tool.cpp
@@ -109,7 +109,7 @@
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/dropper-tool.cpp b/src/ui/tools/dropper-tool.cpp
index 99d42a211..6c55f7484 100644
--- a/src/ui/tools/dropper-tool.cpp
+++ b/src/ui/tools/dropper-tool.cpp
@@ -52,7 +52,7 @@ using Inkscape::DocumentUndo;
 static GdkCursor *cursor_dropper_fill = NULL;
 static GdkCursor *cursor_dropper_stroke = NULL;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/eraser-tool.cpp b/src/ui/tools/eraser-tool.cpp
index 4106785e7..bf4015b4c 100644
--- a/src/ui/tools/eraser-tool.cpp
+++ b/src/ui/tools/eraser-tool.cpp
@@ -84,7 +84,7 @@ using Inkscape::DocumentUndo;
 #define DRAG_DEFAULT 1.0
 #define DRAG_MAX 1.0
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/flood-tool.cpp b/src/ui/tools/flood-tool.cpp
index d74848dc6..5745fc9cc 100644
--- a/src/ui/tools/flood-tool.cpp
+++ b/src/ui/tools/flood-tool.cpp
@@ -50,7 +50,7 @@
 #include "preferences.h"
 #include "rubberband.h"
 #include "selection.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "sp-defs.h"
 #include "sp-item.h"
 #include "splivarot.h"
@@ -74,7 +74,7 @@ using Inkscape::Display::ExtractARGB32;
 using Inkscape::Display::ExtractRGB32;
 using Inkscape::Display::AssembleARGB32;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -119,8 +119,8 @@ FloodTool::~FloodTool() {
  * destroys old and creates new knotholder.
  */
 void FloodTool::selection_changed(Inkscape::Selection* selection) {
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 }
 
 void FloodTool::setup() {
@@ -130,7 +130,7 @@ void FloodTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     this->sel_changed_connection.disconnect();
diff --git a/src/ui/tools/flood-tool.h b/src/ui/tools/flood-tool.h
index 3ed670e8b..5104a42e9 100644
--- a/src/ui/tools/flood-tool.h
+++ b/src/ui/tools/flood-tool.h
@@ -11,9 +11,7 @@
  * Released under GNU GPL
  */
 
-#include <stddef.h>
-#include <sigc++/sigc++.h>
-#include <gtk/gtk.h>
+#include <sigc++/connection.h>
 #include "ui/tools/tool-base.h"
 
 #define SP_FLOOD_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::FloodTool*>((Inkscape::UI::Tools::ToolBase*)obj))
diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index 37a170bc9..6434c30d2 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -30,7 +30,7 @@
 #include "desktop-handles.h"
 #include "desktop-style.h"
 #include "document.h"
-#include "draw-anchor.h"
+#include "ui/draw-anchor.h"
 #include "macros.h"
 #include "message-stack.h"
 #include "ui/tools/pen-tool.h"
@@ -44,6 +44,8 @@
 #include "live_effects/lpe-powerstroke.h"
 #include "style.h"
 #include "ui/control-manager.h"
+// clipboard support
+#include "ui/clipboard.h"
 #include "ui/tools/freehand-base.h"
 
 #include <gdk/gdkkeysyms.h>
@@ -78,6 +80,7 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape, gint hot_x, gint ho
     , red_color(0xff00007f)
     , blue_color(0x0000ff7f)
     , green_color(0x00ff007f)
+    , highlight_color(0x0000007f)
     , red_bpath(NULL)
     , red_curve(NULL)
     , blue_bpath(NULL)
@@ -89,6 +92,7 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape, gint hot_x, gint ho
     , white_item(NULL)
     , white_curves(NULL)
     , white_anchors(NULL)
+    , overwriteCurve(NULL)
     , sa(NULL)
     , ea(NULL)
     , waiting_LPE_type(Inkscape::LivePathEffect::INVALID_LPE)
@@ -144,6 +148,9 @@ void FreehandBase::setup() {
     this->green_anchor = NULL;
     this->green_closed = FALSE;
 
+    // Create start anchor alternative curve
+    this->overwriteCurve = new SPCurve();
+
     this->attach = TRUE;
     spdc_attach_selection(this, this->selection);
 }
@@ -270,8 +277,18 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
         if (prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1) {
             Effect::createAndApply(SPIRO, dc->desktop->doc(), item);
         }
+        //add the bspline node in the waiting effects
+        if (prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2) {
+            Effect::createAndApply(BSPLINE, dc->desktop->doc(), item);
+        }
+
+        //Store the clipboard path to apply in the future without the use of clipboard
+        static Geom::PathVector previous_shape_pathv;
+        enum shapeType { NONE, TRIANGLE_IN, TRIANGLE_OUT, ELLIPSE, CLIPBOARD, LAST_APPLIED };
+        static shapeType previous_shape_type = NONE;
 
-        int shape = prefs->getInt(tool_name(dc) + "/shape", 0);
+
+        shapeType shape = (shapeType)prefs->getInt(tool_name(dc) + "/shape", 0);
         bool shape_applied = false;
         SPCSSAttr *css_item = sp_css_attr_from_object(item, SP_STYLE_FLAG_ALWAYS);
         const char *cstroke = sp_repr_css_property(css_item, "stroke", "none");
@@ -279,11 +296,18 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
 #define SHAPE_LENGTH 10
 #define SHAPE_HEIGHT 10
 
+        if(shape == LAST_APPLIED){
+            shape = previous_shape_type;
+            if(shape == CLIPBOARD){
+                shape = LAST_APPLIED;
+            }
+        }
+
         switch (shape) {
-            case 0:
+            case NONE:
                 // don't apply any shape
                 break;
-            case 1:
+            case TRIANGLE_IN:
             {
                 // "triangle in"
                 std::vector<Geom::Point> points(1);
@@ -293,7 +317,7 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
                 shape_applied = true;
                 break;
             }
-            case 2:
+            case TRIANGLE_OUT:
             {
                 // "triangle out"
                 guint curve_length = curve->get_segment_count();
@@ -304,7 +328,7 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
                 shape_applied = true;
                 break;
             }
-            case 3:
+            case ELLIPSE:
             {
                 // "ellipse"
                 SPCurve *c = new SPCurve();
@@ -317,22 +341,40 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
                 c->closepath();
                 spdc_paste_curve_as_freehand_shape(c, dc, item);
                 c->unref();
+
                 shape_applied = true;
                 break;
             }
-            case 4:
+            case CLIPBOARD:
             {
                 // take shape from clipboard; TODO: catch the case where clipboard is empty
                 Effect::createAndApply(PATTERN_ALONG_PATH, dc->desktop->doc(), item);
                 Effect* lpe = SP_LPE_ITEM(item)->getCurrentLPE();
                 static_cast<LPEPatternAlongPath*>(lpe)->pattern.on_paste_button_click();
+                Inkscape::UI::ClipboardManager *cm = Inkscape::UI::ClipboardManager::get();
+                Glib::ustring svgd = cm->getPathParameter(SP_ACTIVE_DESKTOP);
+                previous_shape_pathv = sp_svg_read_pathv(svgd.data());
 
                 shape_applied = true;
                 break;
             }
+            case LAST_APPLIED:
+            {
+                if(previous_shape_pathv.size() != 0){
+                    SPCurve * c = new SPCurve();
+                    c->set_pathvector(previous_shape_pathv);
+                    spdc_paste_curve_as_freehand_shape(c, dc, item);
+                    c->unref();
+
+                    shape_applied = true;
+                }
+                break;
+            }
             default:
                 break;
         }
+        previous_shape_type = shape;
+
         if (shape_applied) {
             // apply original stroke color as fill and unset stroke; then return
             SPCSSAttr *css = sp_repr_css_attr_new();
@@ -486,7 +528,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
 {
     // Concat RBG
     SPCurve *c = dc->green_curve;
-
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     // Green
     dc->green_curve = new SPCurve();
     while (dc->green_bpaths) {
@@ -533,9 +575,20 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
         if (dc->sa->start && !(dc->sa->curve->is_closed()) ) {
             c = reverse_then_unref(c);
         }
-        dc->sa->curve->append_continuous(c, 0.0625);
-        c->unref();
-        dc->sa->curve->closepath_current();
+        if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || 
+            prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
+            dc->overwriteCurve->append_continuous(c, 0.0625);
+            c->unref();
+            dc->overwriteCurve->closepath_current();
+            if(dc->sa){
+                dc->white_curves = g_slist_remove(dc->white_curves, dc->sa->curve);
+                dc->white_curves = g_slist_append(dc->white_curves, dc->overwriteCurve);
+            }
+        }else{
+            dc->sa->curve->append_continuous(c, 0.0625);
+            c->unref();
+            dc->sa->curve->closepath_current();
+        }
         spdc_flush_white(dc, NULL);
         return;
     }
@@ -544,6 +597,10 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
     if (dc->sa) {
         SPCurve *s = dc->sa->curve;
         dc->white_curves = g_slist_remove(dc->white_curves, s);
+        if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || 
+            prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
+                s = dc->overwriteCurve;
+        }
         if (dc->sa->start) {
             s = reverse_then_unref(s);
         }
@@ -556,6 +613,25 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed)
         if (!dc->ea->start) {
             e = reverse_then_unref(e);
         }
+        if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || 
+            prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){
+                e = reverse_then_unref(e);
+                Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*e->last_segment());
+                SPCurve *lastSeg = new SPCurve();
+                if(cubic){
+                    lastSeg->moveto((*cubic)[0]);
+                    lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
+                    if( e->get_segment_count() == 1){
+                        e = lastSeg;
+                    }else{
+                        //we eliminate the last segment
+                        e->backspace();
+                        //and we add it again with the recreation
+                        e->append_continuous(lastSeg, 0.0625);
+                    }
+                }
+                e = reverse_then_unref(e);
+        }
         c->append_continuous(e, 0.0625);
         e->unref();
     }
@@ -599,6 +675,7 @@ static void spdc_flush_white(FreehandBase *dc, SPCurve *gc)
 
         bool has_lpe = false;
         Inkscape::XML::Node *repr;
+
         if (dc->white_item) {
             repr = dc->white_item->getRepr();
             has_lpe = SP_LPE_ITEM(dc->white_item)->hasPathEffectRecursive();
@@ -662,7 +739,6 @@ SPDrawAnchor *spdc_test_inside(FreehandBase *dc, Geom::Point p)
             active = na;
         }
     }
-
     return active;
 }
 
diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h
index 5a4b91800..6b4265215 100644
--- a/src/ui/tools/freehand-base.h
+++ b/src/ui/tools/freehand-base.h
@@ -55,6 +55,7 @@ public:
     guint32 red_color;
     guint32 blue_color;
     guint32 green_color;
+    guint32 highlight_color;
 
     // Red
     SPCanvasItem *red_bpath;
@@ -75,12 +76,17 @@ public:
     GSList *white_curves;
     GSList *white_anchors;
 
+    //ALternative curve to use on continuing exisiting curve in case of bspline or spirolive 
+    //because usigh anchor curves give memory and random bugs, - and obscure code- in some plataform reported by su_v in mac
+    SPCurve *overwriteCurve;
+
     // Start anchor
     SPDrawAnchor *sa;
 
     // End anchor
     SPDrawAnchor *ea;
 
+
     /* type of the LPE that is to be applied automatically to a finished path (if any) */
     Inkscape::LivePathEffect::EffectType waiting_LPE_type;
 
diff --git a/src/ui/tools/gradient-tool.cpp b/src/ui/tools/gradient-tool.cpp
index a0bbfbaf1..9c853917e 100644
--- a/src/ui/tools/gradient-tool.cpp
+++ b/src/ui/tools/gradient-tool.cpp
@@ -51,7 +51,7 @@
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -213,17 +213,20 @@ sp_gradient_context_is_over_line (GradientTool *rc, SPItem *item, Geom::Point ev
     //Translate mouse point into proper coord system
     rc->mousepoint_doc = desktop->w2d(event_p);
 
-    SPCtrlLine* line = SP_CTRLLINE(item);
+    if (SP_IS_CTRLLINE(item)) {
+        SPCtrlLine* line = SP_CTRLLINE(item);
 
-    Geom::LineSegment ls(line->s, line->e);
-    Geom::Point nearest = ls.pointAt(ls.nearestPoint(rc->mousepoint_doc));
-    double dist_screen = Geom::L2 (rc->mousepoint_doc - nearest) * desktop->current_zoom();
+        Geom::LineSegment ls(line->s, line->e);
+        Geom::Point nearest = ls.pointAt(ls.nearestPoint(rc->mousepoint_doc));
+        double dist_screen = Geom::L2 (rc->mousepoint_doc - nearest) * desktop->current_zoom();
 
-    double tolerance = (double) SP_EVENT_CONTEXT(rc)->tolerance;
+        double tolerance = (double) SP_EVENT_CONTEXT(rc)->tolerance;
 
-    bool close = (dist_screen < tolerance);
+        bool close = (dist_screen < tolerance);
 
-    return close;
+        return close;
+    }
+    return false;
 }
 
 static std::vector<Geom::Point>
diff --git a/src/ui/tools/lpe-tool.cpp b/src/ui/tools/lpe-tool.cpp
index 9ab6d7814..1fd1ebf8c 100644
--- a/src/ui/tools/lpe-tool.cpp
+++ b/src/ui/tools/lpe-tool.cpp
@@ -28,7 +28,7 @@
 #include "desktop.h"
 #include "message-context.h"
 #include "preferences.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "selection.h"
 #include "desktop-handles.h"
 #include "document.h"
@@ -59,7 +59,7 @@ SubtoolEntry lpesubtools[] = {
 };
 
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -129,8 +129,7 @@ void LpeTool::setup() {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     if (item) {
-        this->shape_editor->set_item(item, SH_NODEPATH);
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     if (prefs->getBool("/tools/lpetool/selcue")) {
@@ -146,9 +145,9 @@ void sp_lpetool_context_selection_changed(Inkscape::Selection *selection, gpoint
 {
     LpeTool *lc = SP_LPETOOL_CONTEXT(data);
 
-    lc->shape_editor->unset_item(SH_KNOTHOLDER);
+    lc->shape_editor->unset_item();
     SPItem *item = selection->singleItem();
-    lc->shape_editor->set_item(item, SH_KNOTHOLDER);
+    lc->shape_editor->set_item(item);
 }
 
 void LpeTool::set(const Inkscape::Preferences::Entry& val) {
diff --git a/src/ui/tools/measure-tool.cpp b/src/ui/tools/measure-tool.cpp
index feeb68288..6b5cbeccd 100644
--- a/src/ui/tools/measure-tool.cpp
+++ b/src/ui/tools/measure-tool.cpp
@@ -49,7 +49,7 @@ using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
 using Inkscape::Util::unit_table;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/mesh-tool.cpp b/src/ui/tools/mesh-tool.cpp
index 7d6d3bc23..8a1fb7c72 100644
--- a/src/ui/tools/mesh-tool.cpp
+++ b/src/ui/tools/mesh-tool.cpp
@@ -53,7 +53,7 @@
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/node-tool.cpp b/src/ui/tools/node-tool.cpp
index 4be547506..e2bb85d11 100644
--- a/src/ui/tools/node-tool.cpp
+++ b/src/ui/tools/node-tool.cpp
@@ -23,7 +23,9 @@
 #include "live_effects/lpeobject.h"
 #include "message-context.h"
 #include "selection.h"
-#include "shape-editor.h" // temporary!
+#include "ui/shape-editor.h" // temporary!
+#include "live_effects/effect.h"
+#include "display/curve.h"
 #include "sp-clippath.h"
 #include "sp-item-group.h"
 #include "sp-mask.h"
@@ -105,7 +107,7 @@
 
 using Inkscape::ControlManager;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -171,6 +173,10 @@ NodeTool::~NodeTool() {
         this->desktop->remove_temporary_canvasitem(this->helperpath_tmpitem);
     }
 
+    if (this->helperpath_tmpitem) {
+        this->desktop->remove_temporary_canvasitem(this->helperpath_tmpitem);
+    }
+
     this->_selection_changed_connection.disconnect();
     //this->_selection_modified_connection.disconnect();
     this->_mouseover_changed_connection.disconnect();
@@ -239,7 +245,7 @@ void NodeTool::setup() {
         )
     );
 
-    this->_selected_nodes->signal_point_changed.connect(
+    this->_selected_nodes->signal_selection_changed.connect(
 		// Hide both signal parameters and bind the function parameter to 0
 		// sigc::signal<void, SelectableControlPoint *, bool>
 		// <=>
@@ -257,6 +263,7 @@ void NodeTool::setup() {
     this->flash_tempitem = NULL;
     this->flashed_item = NULL;
     this->_last_over = NULL;
+    this->helperpath_tmpitem = NULL;
 
     // read prefs before adding items to selection to prevent momentarily showing the outline
     sp_event_context_read(this, "show_handles");
@@ -435,7 +442,7 @@ void NodeTool::selection_changed(Inkscape::Selection *sel) {
             this->_shape_editors.find(r.item) == this->_shape_editors.end())
         {
             ShapeEditor *si = new ShapeEditor(this->desktop);
-            si->set_item(r.item, SH_KNOTHOLDER);
+            si->set_item(r.item);
             this->_shape_editors.insert(const_cast<SPItem*&>(r.item), si);
         }
     }
@@ -455,7 +462,7 @@ bool NodeTool::root_handler(GdkEvent* event) {
     
     Inkscape::Selection *selection = desktop->selection;
     static Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    
+
     if (this->_multipath->event(this, event)) {
     	return true;
     }
@@ -473,6 +480,7 @@ bool NodeTool::root_handler(GdkEvent* event) {
     case GDK_MOTION_NOTIFY: {
 	this->update_helperpath();
         combine_motion_events(desktop->canvas, event->motion, 0);
+        this->update_helperpath();
         SPItem *over_item = sp_event_context_find_item (desktop, event_point(event->button),
                 FALSE, TRUE);
 
@@ -481,7 +489,6 @@ bool NodeTool::root_handler(GdkEvent* event) {
             //ink_node_tool_update_tip(nt, event);
             this->update_tip(event);
         }
-
         // create pathflash outline
         if (prefs->getBool("/tools/nodes/pathflash_enabled")) {
             if (over_item == this->flashed_item) {
@@ -513,7 +520,8 @@ bool NodeTool::root_handler(GdkEvent* event) {
             SPCanvasItem *flash = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), c);
 
             sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(flash),
-                prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff), 1.0,
+                //prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff), 1.0,
+                over_item->highlight_color(), 1.0,
                 SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
             sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(flash), 0, SP_WIND_RULE_NONZERO);
diff --git a/src/ui/tools/node-tool.h b/src/ui/tools/node-tool.h
index 459ecd0a7..ab72f3632 100644
--- a/src/ui/tools/node-tool.h
+++ b/src/ui/tools/node-tool.h
@@ -15,6 +15,9 @@
 #include <glib.h>
 #include "ui/tools/tool-base.h"
 
+// we need it to call it from Live Effect
+#include "selection.h"
+
 namespace Inkscape {
 	namespace Display {
 		class TemporaryItem;
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index 649c64034..92937a135 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -26,7 +26,7 @@
 #include "desktop-handles.h"
 #include "selection.h"
 #include "selection-chemistry.h"
-#include "draw-anchor.h"
+#include "ui/draw-anchor.h"
 #include "message-stack.h"
 #include "message-context.h"
 #include "preferences.h"
@@ -40,9 +40,40 @@
 #include <glibmm/i18n.h>
 #include "macros.h"
 #include "context-fns.h"
-#include "tools-switch.h"
+#include "ui/tools-switch.h"
 #include "ui/control-manager.h"
-#include "tool-factory.h"
+// we include the necessary files for BSpline & Spiro
+#include "live_effects/effect.h"
+#include "live_effects/lpeobject.h"
+#include "live_effects/lpeobject-reference.h"
+#include "live_effects/parameter/path.h"
+#define INKSCAPE_LPE_SPIRO_C
+#include "live_effects/lpe-spiro.h"
+
+
+#include <typeinfo>
+#include <2geom/pathvector.h>
+#include <2geom/affine.h>
+#include <2geom/bezier-curve.h>
+#include <2geom/hvlinesegment.h>
+#include "helper/geom-nodetype.h"
+#include "helper/geom-curves.h"
+
+// For handling un-continuous paths:
+#include "message-stack.h"
+#include "inkscape.h"
+#include "desktop.h"
+
+#include "live_effects/spiro.h"
+
+#define INKSCAPE_LPE_BSPLINE_C
+#include "live_effects/lpe-bspline.h"
+#include <2geom/nearest-point.h>
+
+#include "ui/tool-factory.h"
+
+#include "live_effects/effect.h"
+
 
 using Inkscape::ControlManager;
 
@@ -53,7 +84,7 @@ namespace Tools {
 static Geom::Point pen_drag_origin_w(0, 0);
 static bool pen_within_tolerance = false;
 static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical
-
+const double handleCubicGap = 0.01;
 namespace {
     ToolBase* createPenContext() {
         return new PenTool();
@@ -135,8 +166,22 @@ PenTool::~PenTool() {
 void PenTool::setPolylineMode() {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     guint mode = prefs->getInt("/tools/freehand/pen/freehand-mode", 0);
-    this->polylines_only = (mode == 2 || mode == 3);
-    this->polylines_paraxial = (mode == 3);
+    // change the nodes to make space for bspline mode
+    this->polylines_only = (mode == 3 || mode == 4);
+    this->polylines_paraxial = (mode == 4);
+    //we call the function which defines the Spiro modes and the BSpline
+    //todo: merge to one function only
+    this->_pen_context_set_mode(mode);
+}
+
+/*
+*.Set the mode of draw spiro, and bsplines
+*/
+void PenTool::_pen_context_set_mode(guint mode) {
+    // define the nodes
+    this->spiro = (mode == 1);
+    this->bspline = (mode == 2);
+    this->_bspline_spiro_color();
 }
 
 /**
@@ -144,7 +189,6 @@ void PenTool::setPolylineMode() {
  */
 void PenTool::setup() {
     FreehandBase::setup();
-
     ControlManager &mgr = ControlManager::getManager();
 
     // Pen indicators
@@ -195,7 +239,9 @@ void PenTool::finish() {
     sp_event_context_discard_delayed_snap_event(this);
 
     if (this->npoints != 0) {
-        this->_cancel();
+        // switching context - finish path
+        this->ea = NULL; // unset end anchor if set (otherwise crashes)
+        this->_finish(false);
     }
 
     FreehandBase::finish();
@@ -332,9 +378,20 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
 
     Geom::Point const event_w(bevent.x, bevent.y);
     Geom::Point event_dt(desktop->w2d(event_w));
-
+    //Test whether we hit any anchor.
+    SPDrawAnchor * const anchor = spdc_test_inside(this, event_w);
+
+    //with this we avoid creating a new point over the existing one
+    if(bevent.button != 3 && (this->spiro || this->bspline) && this->npoints > 0 && this->p[0] == this->p[3]){
+        if( anchor && anchor == this->sa && this->green_curve->is_empty()){
+            //remove the following line to avoid having one node on top of another
+            _finishSegment(event_dt, bevent.state);
+            _finish( false);
+            return true;
+        }
+        return false;
+    } 
     bool ret = false;
-
     if (bevent.button == 1 && !this->space_panning
         // make sure this is not the last click for a waiting LPE (otherwise we want to finish the path)
         && this->expecting_clicks_for_LPE != 1) {
@@ -355,10 +412,8 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
         pen_drag_origin_w = event_w;
         pen_within_tolerance = true;
 
-        // Test whether we hit any anchor.
-        SPDrawAnchor * const anchor = spdc_test_inside(this, event_w);
-
         switch (this->mode) {
+
             case PenTool::MODE_CLICK:
                 // In click mode we add point on release
                 switch (this->state) {
@@ -380,7 +435,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                         // This is allowed, if we just canceled curve
                     case PenTool::POINT:
                         if (this->npoints == 0) {
-
+                            this->_bspline_spiro_color();
                             Geom::Point p;
                             if ((bevent.state & GDK_CONTROL_MASK) && (this->polylines_only || this->polylines_paraxial)) {
                                 p = event_dt;
@@ -399,8 +454,12 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                             // distinction so that the case of a waiting LPE is treated separately
 
                             // Set start anchor
+
                             this->sa = anchor;
-                            if (anchor && !this->hasWaitingLPE()) {
+                            if(anchor){
+                                this->_bspline_spiro_start_anchor(bevent.state & GDK_SHIFT_MASK);
+                            }
+                            if (anchor && (!this->hasWaitingLPE()|| this->bspline || this->spiro)) {
                                 // Adjust point to anchor if needed; if we have a waiting LPE, we need
                                 // a fresh path to be created so don't continue an existing one
                                 p = anchor->dp;
@@ -422,7 +481,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 // Create green anchor
                                 p = event_dt;
                                 this->_endpointSnap(p, bevent.state);
-                                this->green_anchor = sp_draw_anchor_new(this, this->green_curve, TRUE, p);
+                                this->green_anchor = sp_draw_anchor_new(this, this->green_curve, true, p);
                             }
                             this->_setInitialPoint(p);
                         } else {
@@ -439,7 +498,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 if (this->green_anchor && this->green_anchor->active) {
                                     // we clicked on the current curve start, so close it even if
                                     // we drag a handle away from it
-                                    this->green_closed = TRUE;
+                                    this->green_closed = true;
                                 }
                                 ret = true;
                                 break;
@@ -450,8 +509,8 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 this->_setSubsequentPoint(p, true);
                             }
                         }
-
-                        this->state = this->polylines_only ? PenTool::POINT : PenTool::CONTROL;
+                        // avoid the creation of a control point so a node is created in the release event
+                        this->state = (this->spiro || this->bspline || this->polylines_only) ? PenTool::POINT : PenTool::CONTROL;
                         ret = true;
                         break;
                     case PenTool::CONTROL:
@@ -511,9 +570,11 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
 
     Geom::Point const event_w(mevent.x, mevent.y);
 
+    //we take out the function the const "tolerance" because we need it later
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    gint const tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
+
     if (pen_within_tolerance) {
-        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-        gint const tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
         if ( Geom::LInfty( event_w - pen_drag_origin_w ) < tolerance ) {
             return false;   // Do not drag if we're within tolerance from origin.
         }
@@ -537,7 +598,7 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                         // Only set point, if we are already appending
                         this->_endpointSnap(p, mevent.state);
                         this->_setSubsequentPoint(p, true);
-                        ret = TRUE;
+                        ret = true;
                     } else if (!this->sp_event_context_knot_mouseover()) {
                         SnapManager &m = desktop->namedview->snap_manager;
                         m.setup(desktop);
@@ -573,7 +634,11 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                         }
 
                         if (anchor && !this->anchor_statusbar) {
-                            this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to close and finish the path."));
+                            if(!this->spiro && !this->bspline){
+                                this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to close and finish the path."));
+                            }else{
+                                this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to close and finish the path. Shift+Click make a cusp node"));
+                            }
                             this->anchor_statusbar = true;
                         } else if (!anchor && this->anchor_statusbar) {
                             this->message_context->clear();
@@ -583,11 +648,16 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                         ret = true;
                     } else {
                         if (anchor && !this->anchor_statusbar) {
-                            this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to continue the path from this point."));
+                            if(!this->spiro && !this->bspline){
+                                this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to continue the path from this point."));
+                            }else{
+                                this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to continue the path from this point. Shift+Click make a cusp node"));      
+                            }
                             this->anchor_statusbar = true;
                         } else if (!anchor && this->anchor_statusbar) {
                             this->message_context->clear();
                             this->anchor_statusbar = false;
+
                         }
                         if (!this->sp_event_context_knot_mouseover()) {
                             SnapManager &m = desktop->namedview->snap_manager;
@@ -602,6 +672,7 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                     // Placing controls is last operation in CLOSE state
 
                     // snap the handle
+
                     this->_endpointSnapHandle(p, mevent.state);
 
                     if (!this->polylines_only) {
@@ -609,6 +680,7 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                     } else {
                         this->_setCtrl(this->p[1], mevent.state);
                     }
+
                     gobble_motion_events(GDK_BUTTON1_MASK);
                     ret = true;
                     break;
@@ -628,6 +700,16 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
         default:
             break;
     }
+    // calls the function "bspline_spiro_motion" when the mouse starts or stops moving
+    if(this->bspline){
+        this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK);
+    }else{
+        if ( Geom::LInfty( event_w - pen_drag_origin_w ) > (tolerance/2) || mevent.time == 0) {
+            this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK);
+            pen_drag_origin_w = event_w;
+        }
+    }
+
     return ret;
 }
 
@@ -649,7 +731,12 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
         Geom::Point p = this->desktop->w2d(event_w);
 
         // Test whether we hit any anchor.
+
         SPDrawAnchor *anchor = spdc_test_inside(this, event_w);
+        // if we try to create a node in the same place as another node, we skip
+        if((!anchor || anchor == this->sa) && (this->spiro || this->bspline) && this->npoints > 0 && this->p[0] == this->p[3]){
+            return true;
+        }
 
         switch (this->mode) {
             case PenTool::MODE_CLICK:
@@ -657,10 +744,17 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                     case PenTool::POINT:
                         if ( this->npoints == 0 ) {
                             // Start new thread only with button release
+                            this->_bspline_spiro_color();
                             if (anchor) {
                                 p = anchor->dp;
                             }
                             this->sa = anchor;
+                            // continue the existing curve
+                            if (anchor) {
+                                if(this->bspline || this->spiro){
+                                    this->_bspline_spiro_start_anchor(revent.state & GDK_SHIFT_MASK);;
+                                }
+                            }
                             this->_setInitialPoint(p);
                         } else {
                             // Set end anchor here
@@ -685,6 +779,10 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                             this->_endpointSnap(p, revent.state);
                         }
                         this->_finishSegment(p, revent.state);
+                        // hude the guide of the penultimate node when closing the curve
+                        if(this->spiro){
+                            sp_canvas_item_hide(this->c1);
+                        }
                         this->_finish(true);
                         this->state = PenTool::POINT;
                         ret = true;
@@ -708,6 +806,10 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                     case PenTool::CLOSE:
                         this->_endpointSnap(p, revent.state);
                         this->_finishSegment(p, revent.state);
+                        // hide the penultimate node guide when closing the curve
+                        if(this->spiro){
+                            sp_canvas_item_hide(this->c1);
+                        }
                         if (this->green_closed) {
                             // finishing at the start anchor, close curve
                             this->_finish(true);
@@ -728,7 +830,6 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
             default:
                 break;
         }
-
         if (this->grab) {
             // Release grab now
             sp_canvas_item_ungrab(this->grab, revent.time);
@@ -737,7 +838,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
 
         ret = true;
 
-        this->green_closed = FALSE;
+        this->green_closed = false;
     }
 
     // TODO: can we be sure that the path was created correctly?
@@ -765,7 +866,7 @@ bool PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
     bool ret = false;
     // only end on LMB double click. Otherwise horizontal scrolling causes ending of the path
     if (this->npoints != 0 && bevent.button == 1) {
-        this->_finish(FALSE);
+        this->_finish(false);
         ret = true;
     }
     return ret;
@@ -786,7 +887,6 @@ void PenTool::_redrawAll() {
 
         this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
     }
-
     if (this->green_anchor)
         SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp);
 
@@ -796,7 +896,8 @@ void PenTool::_redrawAll() {
     sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
 
     // handles
-    if (this->p[0] != this->p[1]) {
+    // hide the handlers in bspline and spiro modes
+    if (this->p[0] != this->p[1] && !this->spiro && !this->bspline) {
         SP_CTRL(this->c1)->moveto(this->p[1]);
         this->cl1->setCoords(this->p[0], this->p[1]);
         sp_canvas_item_show(this->c1);
@@ -809,8 +910,9 @@ void PenTool::_redrawAll() {
     Geom::Curve const * last_seg = this->green_curve->last_segment();
     if (last_seg) {
         Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( last_seg );
+        // hide the handlers in bspline and spiro modes
         if ( cubic &&
-             (*cubic)[2] != this->p[0] )
+             (*cubic)[2] != this->p[0] && !this->spiro && !this->bspline )
         {
             Geom::Point p2 = (*cubic)[2];
             SP_CTRL(this->c0)->moveto(p2);
@@ -822,6 +924,10 @@ void PenTool::_redrawAll() {
             sp_canvas_item_hide(this->cl0);
         }
     }
+
+    // simply redraw the spiro. because its a redrawing, we don't call the global function, 
+    // but we call the redrawing at the ending.
+     this->_bspline_spiro_build();
 }
 
 void PenTool::_lastpointMove(gdouble x, gdouble y) {
@@ -839,6 +945,7 @@ void PenTool::_lastpointMove(gdouble x, gdouble y) {
     }
 
     // red
+
     this->p[0] += Geom::Point(x, y);
     this->p[1] += Geom::Point(x, y);
     this->_redrawAll();
@@ -849,25 +956,105 @@ void PenTool::_lastpointMoveScreen(gdouble x, gdouble y) {
 }
 
 void PenTool::_lastpointToCurve() {
-    if (this->npoints != 5)
+    // avoid that if the "red_curve" contains only two points ( rect ), it doesn't stop here.
+    if (this->npoints != 5 && !this->spiro && !this->bspline)
         return;
 
-    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( this->green_curve->last_segment() );
-    if ( cubic ) {
-        this->p[1] = this->p[0] + (Geom::Point)( (*cubic)[3] - (*cubic)[2] );
-    } else {
-        this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]);
+    this->p[1] = this->red_curve->last_segment()->initialPoint() + (1./3.)*(this->red_curve->last_segment()->finalPoint() - this->red_curve->last_segment()->initialPoint());
+    //modificate the last segment of the green curve so it creates the type of node we need
+    if (this->spiro||this->bspline) {
+        if (!this->green_curve->is_empty()) {
+            Geom::Point A(0,0);
+            Geom::Point B(0,0);
+            Geom::Point C(0,0);
+            Geom::Point D(0,0);
+            Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>( this->green_curve->last_segment() );
+            //We obtain the last segment 4 points in the previous curve 
+            if ( cubic ){
+                A = (*cubic)[0];
+                B = (*cubic)[1];
+                if (this->spiro) {
+                    C = this->p[0] + (this->p[0] - this->p[1]);
+                } else {
+                    C = this->green_curve->last_segment()->finalPoint() + (1./3.)*(this->green_curve->last_segment()->initialPoint() - this->green_curve->last_segment()->finalPoint());
+                }
+                D = (*cubic)[3];
+            } else {
+                A = this->green_curve->last_segment()->initialPoint();
+                B = this->green_curve->last_segment()->initialPoint();
+                if (this->spiro) {
+                    C = this->p[0] + (this->p[0] - this->p[1]);
+                } else {
+                    C = this->green_curve->last_segment()->finalPoint() + (1./3.)*(this->green_curve->last_segment()->initialPoint() - this->green_curve->last_segment()->finalPoint());
+                }
+                D = this->green_curve->last_segment()->finalPoint();
+            }
+            SPCurve *previous = new SPCurve();
+            previous->moveto(A);
+            previous->curveto(B, C, D);
+            if ( this->green_curve->get_segment_count() == 1) {
+                this->green_curve = previous;
+            } else {
+                //we eliminate the last segment
+                this->green_curve->backspace();
+                //and we add it again with the recreation
+                this->green_curve->append_continuous(previous, 0.0625);
+            }
+        }
+        //if the last node is an union with another curve
+        if (this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()) {
+            this->_bspline_spiro_start_anchor(false);
+        }
     }
 
     this->_redrawAll();
 }
 
+
 void PenTool::_lastpointToLine() {
-    if (this->npoints != 5)
+    // avoid that if the "red_curve" contains only two points ( rect) it doesn't stop here.
+    if (this->npoints != 5 && !this->bspline)
         return;
 
+    // modify the last segment of the green curve so the type of node we want is created.
+    if(this->spiro || this->bspline){
+        if(!this->green_curve->is_empty()){
+            Geom::Point A(0,0);
+            Geom::Point B(0,0);
+            Geom::Point C(0,0);
+            Geom::Point D(0,0);
+            SPCurve * previous = new SPCurve();
+            Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( this->green_curve->last_segment() );
+            if ( cubic ) {
+                A = this->green_curve->last_segment()->initialPoint();
+                B = (*cubic)[1];
+                C = this->green_curve->last_segment()->finalPoint();
+                D = C;
+            } else {
+                //We obtain the last segment 4 points in the previous curve 
+                A = this->green_curve->last_segment()->initialPoint();
+                B = A;
+                C = this->green_curve->last_segment()->finalPoint();
+                D = C;
+            }
+            previous->moveto(A);
+            previous->curveto(B, C, D);
+            if( this->green_curve->get_segment_count() == 1){
+                this->green_curve = previous;
+            }else{
+                //we eliminate the last segment
+                this->green_curve->backspace();
+                //and we add it again with the recreation
+                this->green_curve->append_continuous(previous, 0.0625);
+            }
+        }
+        // if the last node is an union with another curve
+        if(this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()){
+            this->_bspline_spiro_start_anchor(true);
+        }
+    }
+    
     this->p[1] = this->p[0];
-
     this->_redrawAll();
 }
 
@@ -972,7 +1159,7 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_p:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::PARALLEL, 2);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -980,7 +1167,7 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_c:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::CIRCLE_3PTS, 3);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -988,7 +1175,7 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_b:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::PERP_BISECTOR, 2);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -996,7 +1183,7 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_a:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::ANGLE_BISECTOR, 3);
-                ret = TRUE;
+                ret = true;
             }
             break;
 */
@@ -1071,15 +1258,23 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
                     g_warning("pen_handle_key_press, case GDK_KP_Delete: Green curve is empty");
                     break;
                 }
-                // The code below assumes that pc->green_curve has only ONE path !
+                // The code below assumes that this->green_curve has only ONE path !
                 Geom::Curve const * crv = this->green_curve->last_segment();
                 this->p[0] = crv->initialPoint();
                 if ( Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>(crv)) {
                     this->p[1] = (*cubic)[1];
+
                 } else {
                     this->p[1] = this->p[0];
                 }
+
+                // asign the value in a third of the distance of the last segment.
+                if (this->bspline){
+                    this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]);
+                }
+
                 Geom::Point const pt( (this->npoints < 4) ? crv->finalPoint() : this->p[3] );
+
                 this->npoints = 2;
                 // delete the last segment of the green curve
                 if (this->green_curve->get_segment_count() == 1) {
@@ -1094,6 +1289,18 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
                 } else {
                     this->green_curve->backspace();
                 }
+
+                // assign the value of this->p[1] to the oposite of the green line last segment 
+                if (this->spiro){
+                    Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(this->green_curve->last_segment());
+                    if ( cubic ) {
+                        this->p[1] = (*cubic)[3] + (*cubic)[3] - (*cubic)[2];
+                        SP_CTRL(this->c1)->moveto(this->p[0]);
+                    } else {
+                        this->p[1] = this->p[0];
+                    }
+                }
+
                 sp_canvas_item_hide(this->c0);
                 sp_canvas_item_hide(this->c1);
                 sp_canvas_item_hide(this->cl0);
@@ -1101,6 +1308,9 @@ bool PenTool::_handleKeyPress(GdkEvent *event) {
                 this->state = PenTool::POINT;
                 this->_setSubsequentPoint(pt, true);
                 pen_last_paraxial_dir = !pen_last_paraxial_dir;
+
+                //redraw
+                this->_bspline_spiro_build();
                 ret = true;
             }
             break;
@@ -1167,11 +1377,686 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t
     }
 
     this->message_context->setF(Inkscape::IMMEDIATE_MESSAGE, message, angle, dist->str);
-    g_string_free(dist, FALSE);
+    g_string_free(dist, false);
+}
+
+// this function changes the colors red, green and blue making them transparent or not, depending on if spiro is being used.
+void PenTool::_bspline_spiro_color()
+{
+    static Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    if(this->spiro){
+        this->red_color = 0xff00000;
+        this->green_color = 0x00ff000;
+    }else if(this->bspline){
+        this->highlight_color = SP_ITEM(this->desktop->currentLayer())->highlight_color();
+        if((unsigned int)prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff) == this->highlight_color){
+            this->green_color = 0xff00007f;
+            this->red_color = 0xff00007f;
+        } else {
+            this->green_color = this->highlight_color;
+            this->red_color = this->highlight_color;
+        }
+    }else{
+        this->highlight_color = SP_ITEM(this->desktop->currentLayer())->highlight_color();
+        this->red_color = 0xff00007f;
+        if((unsigned int)prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff) == this->highlight_color){
+            this->green_color = 0x00ff007f;
+        } else {
+            this->green_color = this->highlight_color;
+        }
+        sp_canvas_item_hide(this->blue_bpath);
+    }
+    //We erase all the "green_bpaths" to recreate them after with the colour
+    //transparency recently modified
+    if (this->green_bpaths) {
+        // remove old piecewise green canvasitems
+        while (this->green_bpaths) {
+            sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
+            this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
+        }
+        // one canvas bpath for all of green_curve
+        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), this->green_curve);
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO);
+        this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
+    }
+    sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->red_bpath), this->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+}
+
+
+void PenTool::_bspline_spiro(bool shift)
+{
+    if(!this->spiro && !this->bspline)
+        return;
+
+    shift?this->_bspline_spiro_off():this->_bspline_spiro_on();
+    this->_bspline_spiro_build();
+}
+
+void PenTool::_bspline_spiro_on()
+{
+    if(!this->red_curve->is_empty()){
+        using Geom::X;
+        using Geom::Y;
+        this->npoints = 5;
+        this->p[0] = this->red_curve->first_segment()->initialPoint();
+        this->p[3] = this->red_curve->first_segment()->finalPoint();
+        this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
+        this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
+    }
+}
+
+void PenTool::_bspline_spiro_off()
+{
+    if(!this->red_curve->is_empty()){
+        this->npoints = 5;
+        this->p[0] = this->red_curve->first_segment()->initialPoint();
+        this->p[3] = this->red_curve->first_segment()->finalPoint();
+        this->p[2] = this->p[3];
+    }
+}
+
+void PenTool::_bspline_spiro_start_anchor(bool shift)
+{
+    if(this->sa->curve->is_empty()){
+        return;
+    }
+
+    LivePathEffect::LPEBSpline *lpe_bsp = NULL;
+
+    if (SP_IS_LPE_ITEM(this->white_item) && SP_LPE_ITEM(this->white_item)->hasPathEffect()){
+        Inkscape::LivePathEffect::Effect* thisEffect = SP_LPE_ITEM(this->white_item)->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
+        if(thisEffect){
+            lpe_bsp = dynamic_cast<LivePathEffect::LPEBSpline*>(thisEffect->getLPEObj()->get_lpe());
+        }
+    }
+    if(lpe_bsp){
+        this->bspline = true;
+    }else{
+        this->bspline = false;
+    }
+    LivePathEffect::LPESpiro *lpe_spi = NULL;
+
+    if (SP_IS_LPE_ITEM(this->white_item) && SP_LPE_ITEM(this->white_item)->hasPathEffect()){
+        Inkscape::LivePathEffect::Effect* thisEffect = SP_LPE_ITEM(this->white_item)->getPathEffectOfType(Inkscape::LivePathEffect::SPIRO);
+        if(thisEffect){
+            lpe_spi = dynamic_cast<LivePathEffect::LPESpiro*>(thisEffect->getLPEObj()->get_lpe());
+        }
+    }
+    if(lpe_spi){
+        this->spiro = true;
+    }else{
+        this->spiro = false;
+    }
+    if(!this->spiro && !this->bspline)
+        return;
+
+    if(shift)
+        this->_bspline_spiro_start_anchor_off();
+    else
+        this->_bspline_spiro_start_anchor_on();
+}
+
+void PenTool::_bspline_spiro_start_anchor_on()
+{
+    using Geom::X;
+    using Geom::Y;
+    SPCurve *tmpCurve = new SPCurve();
+    tmpCurve = this->sa->curve->copy();
+    if(this->sa->start)
+        tmpCurve = tmpCurve->create_reverse();
+    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+    SPCurve *lastSeg = new SPCurve();
+    Geom::Point A = tmpCurve->last_segment()->initialPoint();
+    Geom::Point D = tmpCurve->last_segment()->finalPoint();
+    Geom::Point C = D + (1./3)*(A - D);
+    C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap);
+    if(cubic){
+        lastSeg->moveto(A);
+        lastSeg->curveto((*cubic)[1],C,D);
+    }else{
+        lastSeg->moveto(A);
+        lastSeg->curveto(A,C,D);
+    }
+    if( tmpCurve->get_segment_count() == 1){
+        tmpCurve = lastSeg;
+    }else{
+        //we eliminate the last segment
+        tmpCurve->backspace();
+        //and we add it again with the recreation
+        tmpCurve->append_continuous(lastSeg, 0.0625);
+    }
+    if (this->sa->start) {
+        tmpCurve = tmpCurve->create_reverse();
+    }
+    this->overwriteCurve = tmpCurve;
+}
+
+void PenTool::_bspline_spiro_start_anchor_off()
+{
+    SPCurve *tmpCurve = new SPCurve();
+    tmpCurve = this->sa->curve->copy();
+    if(this->sa->start)
+        tmpCurve = tmpCurve->create_reverse();
+    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+    if(cubic){
+        SPCurve *lastSeg = new SPCurve();
+        lastSeg->moveto((*cubic)[0]);
+        lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
+        if( tmpCurve->get_segment_count() == 1){
+            tmpCurve = lastSeg;
+        }else{
+            //we eliminate the last segment
+            tmpCurve->backspace();
+            //and we add it again with the recreation
+            tmpCurve->append_continuous(lastSeg, 0.0625);
+        }
+    }
+    if (this->sa->start) {
+        tmpCurve = tmpCurve->create_reverse();
+    }
+    this->overwriteCurve = tmpCurve;
+}
+
+void PenTool::_bspline_spiro_motion(bool shift){
+    if(!this->spiro && !this->bspline)
+        return;
+
+    using Geom::X;
+    using Geom::Y;
+    if(this->red_curve->is_empty()) return;
+    this->npoints = 5;
+    SPCurve *tmpCurve = new SPCurve();
+    this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
+    this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
+    if(this->green_curve->is_empty() && !this->sa){
+        this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]);
+        this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap);
+        if(shift){
+            this->p[2] = this->p[3];
+        }
+    }else if(!this->green_curve->is_empty()){
+        tmpCurve = this->green_curve->copy();
+    }else{
+        tmpCurve = this->overwriteCurve->copy();
+        if(this->sa->start)
+            tmpCurve = tmpCurve->create_reverse();
+    }
+
+    if(!tmpCurve->is_empty()){
+        Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+        if(cubic){
+            if(this->bspline){
+                SPCurve * WPower = new SPCurve();
+                Geom::D2< Geom::SBasis > SBasisWPower;
+                WPower->moveto(tmpCurve->last_segment()->finalPoint());
+                WPower->lineto(tmpCurve->last_segment()->initialPoint());
+                float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment());
+                WPower->reset();
+                WPower->moveto(this->red_curve->last_segment()->initialPoint());
+                WPower->lineto(this->red_curve->last_segment()->finalPoint());
+                SBasisWPower = WPower->first_segment()->toSBasis();
+                WPower->reset();
+                this->p[1] = SBasisWPower.valueAt(WP);
+                if(!Geom::are_near(this->p[1],this->p[0])){
+                    this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap);
+                } else {
+                    this->p[1] = this->p[0];
+                }
+                if(shift)
+                    this->p[2] = this->p[3];
+            }else{
+                this->p[1] =  (*cubic)[3] + ((*cubic)[3] - (*cubic)[2] );
+            }
+        }else{
+            this->p[1] = this->p[0];
+            if(shift)
+                this->p[2] = this->p[3];
+        }
+    }
+
+    if(this->anchor_statusbar && !this->red_curve->is_empty()){
+        if(shift){
+            this->_bspline_spiro_end_anchor_off();
+        }else{
+            this->_bspline_spiro_end_anchor_on();
+        }
+    }
+
+    this->_bspline_spiro_build();
+}
+
+void PenTool::_bspline_spiro_end_anchor_on()
+{
+
+    using Geom::X;
+    using Geom::Y;
+    this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]);
+    this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap);
+    SPCurve *tmpCurve = new SPCurve();
+    SPCurve *lastSeg = new SPCurve();
+    Geom::Point C(0,0);
+    bool reverse = false;
+    if( this->green_anchor && this->green_anchor->active ){
+        tmpCurve = this->green_curve->create_reverse();
+        if(this->green_curve->get_segment_count()==0){
+            return;
+        }
+        reverse = true;
+    } else if(this->sa){
+        tmpCurve = this->overwriteCurve->copy();
+        if(!this->sa->start){
+            tmpCurve = tmpCurve->create_reverse();
+            reverse = true;
+        }
+    }else{
+        return;
+    }
+    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+    if(this->bspline){
+        C = tmpCurve->last_segment()->finalPoint() + (1./3)*(tmpCurve->last_segment()->initialPoint() - tmpCurve->last_segment()->finalPoint());
+        C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap);
+    }else{
+        C = this->p[3] + this->p[3] - this->p[2];
+    }
+    if(cubic){
+        lastSeg->moveto((*cubic)[0]);
+        lastSeg->curveto((*cubic)[1],C,(*cubic)[3]);
+    }else{
+        lastSeg->moveto(tmpCurve->last_segment()->initialPoint());
+        lastSeg->lineto(tmpCurve->last_segment()->finalPoint());
+    }
+    if( tmpCurve->get_segment_count() == 1){
+        tmpCurve = lastSeg;
+    }else{
+        //we eliminate the last segment
+        tmpCurve->backspace();
+        //and we add it again with the recreation
+        tmpCurve->append_continuous(lastSeg, 0.0625);
+    }
+    if (reverse) {
+        tmpCurve = tmpCurve->create_reverse();
+    }
+    if( this->green_anchor && this->green_anchor->active )
+    {
+        this->green_curve->reset();
+        this->green_curve = tmpCurve;
+    }else{
+        this->overwriteCurve->reset();
+        this->overwriteCurve = tmpCurve;
+    }
+}
+
+void PenTool::_bspline_spiro_end_anchor_off()
+{
+
+    SPCurve *tmpCurve = new SPCurve();
+    SPCurve *lastSeg = new SPCurve();
+    bool reverse = false;
+    this->p[2] = this->p[3];
+    if( this->green_anchor && this->green_anchor->active ){
+        tmpCurve = this->green_curve->create_reverse();
+        if(this->green_curve->get_segment_count()==0){
+            return;
+        }
+        reverse = true;
+    } else if(this->sa){
+        tmpCurve = this->overwriteCurve->copy();
+        if(!this->sa->start){
+            tmpCurve = tmpCurve->create_reverse();
+            reverse = true;
+        }
+    }else{
+        return;
+    }
+    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+    if(cubic){
+        lastSeg->moveto((*cubic)[0]);
+        lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]);
+    }else{
+        lastSeg->moveto(tmpCurve->last_segment()->initialPoint());
+        lastSeg->lineto(tmpCurve->last_segment()->finalPoint());
+    }
+    if( tmpCurve->get_segment_count() == 1){
+        tmpCurve = lastSeg;
+    }else{
+        //we eliminate the last segment
+        tmpCurve->backspace();
+        //and we add it again with the recreation
+        tmpCurve->append_continuous(lastSeg, 0.0625);
+    }
+    if (reverse) {
+        tmpCurve = tmpCurve->create_reverse();
+    }
+    if( this->green_anchor && this->green_anchor->active )
+    {
+        this->green_curve->reset();
+        this->green_curve = tmpCurve;
+    }else{
+        this->overwriteCurve->reset();
+        this->overwriteCurve = tmpCurve;
+    }
+}
+
+//prepares the curves for its transformation into BSpline curve.
+void PenTool::_bspline_spiro_build()
+{
+    if(!this->spiro && !this->bspline){
+        return;
+    }
+
+    //We create the base curve
+    SPCurve *curve = new SPCurve();
+    //If we continuate the existing curve we add it at the start
+    if(this->sa && !this->sa->curve->is_empty()){
+        curve = this->overwriteCurve->copy();
+        if (this->sa->start) {
+            curve = curve->create_reverse();
+        }
+    }
+
+    if (!this->green_curve->is_empty()){
+        curve->append_continuous(this->green_curve, 0.0625);
+    }
+
+    //and the red one
+    if (!this->red_curve->is_empty()){
+        this->red_curve->reset();
+        this->red_curve->moveto(this->p[0]);
+        if(this->anchor_statusbar && !this->sa && !(this->green_anchor && this->green_anchor->active)){
+            this->red_curve->curveto(this->p[1],this->p[3],this->p[3]);
+        }else{
+            this->red_curve->curveto(this->p[1],this->p[2],this->p[3]);
+        }
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
+        curve->append_continuous(this->red_curve, 0.0625);
+    }
+
+    if(!curve->is_empty()){
+        // close the curve if the final points of the curve are close enough
+        if(Geom::are_near(curve->first_path()->initialPoint(), curve->last_path()->finalPoint())){
+            curve->closepath_current();
+        }
+        //TODO: CALL TO CLONED FUNCTION SPIRO::doEffect IN lpe-spiro.cpp
+        //For example
+        //using namespace Inkscape::LivePathEffect;
+        //LivePathEffectObject *lpeobj = static_cast<LivePathEffectObject*> (curve);
+        //Effect *spr = static_cast<Effect*> ( new LPEbspline(lpeobj) );
+        //spr->doEffect(curve);
+        if(this->bspline){
+            this->_bspline_doEffect(curve);
+        }else{
+            this->_spiro_doEffect(curve);
+        }
+
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), curve);   
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->blue_bpath), this->blue_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        sp_canvas_item_show(this->blue_bpath);
+        curve->unref();
+        this->blue_curve->reset();
+        //We hide the holders that doesn't contribute anything
+        if(this->spiro){
+            sp_canvas_item_show(this->c1);
+            SP_CTRL(this->c1)->moveto(this->p[0]);
+        }else
+            sp_canvas_item_hide(this->c1);
+        sp_canvas_item_hide(this->cl1);
+        sp_canvas_item_hide(this->c0);
+        sp_canvas_item_hide(this->cl0);
+    }else{
+        //if the curve is empty
+        sp_canvas_item_hide(this->blue_bpath);
+
+    }
+}
+
+void PenTool::_bspline_doEffect(SPCurve * curve)
+{
+    // commenting the function doEffect in src/live_effects/lpe-bspline.cpp
+    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())
+            continue;
+        //Itreadores
+
+        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 previousNode(0, 0);
+        Geom::Point node(0, 0);
+        Geom::Point pointAt1(0, 0);
+        Geom::Point pointAt2(0, 0);
+        Geom::Point nextPointAt1(0, 0);
+        Geom::D2<Geom::SBasis> SBasisIn;
+        Geom::D2<Geom::SBasis> SBasisOut;
+        Geom::D2<Geom::SBasis> SBasisHelper;
+        Geom::CubicBezier const *cubic = NULL;
+        if (path_it->closed()) {
+            const Geom::Curve &closingline =
+                path_it->back_closed(); // the closing line segment is always of type
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                curve_endit = path_it->end_open();
+            }
+        }
+        nCurve->moveto(curve_it1->initialPoint());
+        while (curve_it1 != curve_endit) {
+            SPCurve *in = new SPCurve();
+            in->moveto(curve_it1->initialPoint());
+            in->lineto(curve_it1->finalPoint());
+            cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+            if (cubic) {
+                SBasisIn = in->first_segment()->toSBasis();
+                if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
+                    pointAt1 = SBasisIn.valueAt(0.3334);
+                } else {
+                    pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment()));
+                }
+                if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) {
+                    pointAt2 = SBasisIn.valueAt(0.6667);
+                } else {
+                    pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment()));
+                }
+            } else {
+                pointAt1 = in->first_segment()->initialPoint();
+                pointAt2 = in->first_segment()->finalPoint();
+            }
+            in->reset();
+            delete in;
+            if ( curve_it2 != curve_endit ) {
+                SPCurve *out = new SPCurve();
+                out->moveto(curve_it2->initialPoint());
+                out->lineto(curve_it2->finalPoint());
+                cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it2);
+                if (cubic) {
+                    SBasisOut = out->first_segment()->toSBasis();
+                    if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) {
+                        nextPointAt1 = SBasisIn.valueAt(0.3334);
+                    } else {
+                        nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment()));
+                    }
+                } else {
+                    nextPointAt1 = out->first_segment()->initialPoint();
+                }
+                out->reset();
+                delete out;
+            }
+            Geom::Point startNode = path_it->begin()->initialPoint();
+            if (path_it->closed() && curve_it2 == curve_endit) {
+                SPCurve *start = new SPCurve();
+                start->moveto(path_it->begin()->initialPoint());
+                start->lineto(path_it->begin()->finalPoint());
+                Geom::D2<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
+                SPCurve *lineHelper = new SPCurve();
+                cubic = dynamic_cast<Geom::CubicBezier const *>(&*path_it->begin());
+                if (cubic) {
+                    lineHelper->moveto(SBasisStart.valueAt(
+                                           Geom::nearest_point((*cubic)[1], *start->first_segment())));
+                } else {
+                    lineHelper->moveto(start->first_segment()->initialPoint());
+                }
+                start->reset();
+                delete start;
+
+                SPCurve *end = new SPCurve();
+                end->moveto(curve_it1->initialPoint());
+                end->lineto(curve_it1->finalPoint());
+                Geom::D2<Geom::SBasis> SBasisEnd = end->first_segment()->toSBasis();
+                cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
+                if (cubic) {
+                    lineHelper->lineto(SBasisEnd.valueAt(
+                                           Geom::nearest_point((*cubic)[2], *end->first_segment())));
+                } else {
+                    lineHelper->lineto(end->first_segment()->finalPoint());
+                }
+                end->reset();
+                delete end;
+                SBasisHelper = lineHelper->first_segment()->toSBasis();
+                lineHelper->reset();
+                delete lineHelper;
+                startNode = SBasisHelper.valueAt(0.5);
+                nCurve->curveto(pointAt1, pointAt2, startNode);
+                nCurve->move_endpoints(startNode, startNode);
+            } else if ( curve_it2 == curve_endit) {
+                nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint());
+                nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint());
+            } else {
+                SPCurve *lineHelper = new SPCurve();
+                lineHelper->moveto(pointAt2);
+                lineHelper->lineto(nextPointAt1);
+                SBasisHelper = lineHelper->first_segment()->toSBasis();
+                lineHelper->reset();
+                delete lineHelper;
+                previousNode = node;
+                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]))) {
+                    node = curve_it1->finalPoint();
+                }
+                nCurve->curveto(pointAt1, pointAt2, node);
+            }
+            ++curve_it1;
+            ++curve_it2;
+        }
+        if (path_it->closed()) {
+            nCurve->closepath_current();
+        }
+        curve->append(nCurve, false);
+        nCurve->reset();
+        delete nCurve;
+    }
+}
+
+//Spiro function cloned from lpe-spiro.cpp
+// commenting the function "doEffect" from src/live_effects/lpe-spiro.cpp
+void PenTool::_spiro_doEffect(SPCurve * curve)
+{
+    using Geom::X;
+    using Geom::Y;
+
+    Geom::PathVector const original_pathv = curve->get_pathvector();
+    guint len = curve->get_segment_count() + 2;
+
+    curve->reset();
+    Spiro::spiro_cp *path = g_new (Spiro::spiro_cp, len);
+    int ip = 0;
+
+    for(Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
+        if (path_it->empty())
+            continue;
+
+        {
+            Geom::Point p = path_it->front().pointAt(0);
+            path[ip].x = p[X];
+            path[ip].y = p[Y];
+            path[ip].ty = '{' ;
+            ip++;
+        }
+
+        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();
+        if (path_it->closed()) {
+            const Geom::Curve &closingline = path_it->back_closed(); 
+            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
+                curve_endit = path_it->end_open();
+            }
+        }
+
+        while ( curve_it2 != curve_endit )
+        {
+            Geom::Point p = curve_it1->finalPoint();
+            path[ip].x = p[X];
+            path[ip].y = p[Y];
+
+            bool this_is_line = is_straight_curve(*curve_it1);
+            bool next_is_line = is_straight_curve(*curve_it2);
+
+            Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, *curve_it2);
+
+            if ( nodetype == Geom::NODE_SMOOTH || nodetype == Geom::NODE_SYMM )
+            {
+                if (this_is_line && !next_is_line) {
+                    path[ip].ty = ']';
+                } else if (next_is_line && !this_is_line) {
+                    path[ip].ty = '[';
+                } else {
+                    path[ip].ty = 'c';
+                }
+            } else {
+                path[ip].ty = 'v';
+            }
+
+            ++curve_it1;
+            ++curve_it2;
+            ip++;
+        }
+
+        Geom::Point p = curve_it1->finalPoint();
+        path[ip].x = p[X];
+        path[ip].y = p[Y];
+        if (path_it->closed()) {
+            Geom::NodeType nodetype = Geom::get_nodetype(*curve_it1, path_it->front());
+            switch (nodetype) {
+                case Geom::NODE_NONE:
+                    path[ip].ty = '}';
+                    ip++;
+                    break;
+                case Geom::NODE_CUSP:
+                    path[0].ty = path[ip].ty = 'v';
+                    break;
+                case Geom::NODE_SMOOTH:
+                case Geom::NODE_SYMM:
+                    path[0].ty = path[ip].ty = 'c';
+                    break;
+            }
+        } else {
+            path[ip].ty = '}';
+            ip++;
+        }
+
+        int sp_len = ip;
+        Spiro::spiro_run(path, sp_len, *curve);
+        ip = 0;
+    }
+
+    g_free (path);
 }
 
 void PenTool::_setSubsequentPoint(Geom::Point const p, bool statusbar, guint status) {
     g_assert( this->npoints != 0 );
+
     // todo: Check callers to see whether 2 <= npoints is guaranteed.
 
     this->p[2] = p;
@@ -1195,7 +2080,7 @@ void PenTool::_setSubsequentPoint(Geom::Point const p, bool statusbar, guint sta
         is_curve = false;
     } else {
         // one of the 'regular' modes
-        if (this->p[1] != this->p[0]) {
+        if (this->p[1] != this->p[0] || this->spiro) {
             this->red_curve->curveto(this->p[1], p, p);
             is_curve = true;
         } else {
@@ -1210,10 +2095,16 @@ void PenTool::_setSubsequentPoint(Geom::Point const p, bool statusbar, guint sta
         gchar *message = is_curve ?
             _("<b>Curve segment</b>: angle %3.2f&#176;, distance %s; with <b>Ctrl</b> to snap angle, <b>Enter</b> to finish the path" ):
             _("<b>Line segment</b>: angle %3.2f&#176;, distance %s; with <b>Ctrl</b> to snap angle, <b>Enter</b> to finish the path");
+        if(this->spiro || this->bspline){
+            message = is_curve ?
+            _("<b>Curve segment</b>: angle %3.2f&#176;, distance %s; with <b>Shift+Click</b> make a cusp node, <b>Enter</b> to finish the path" ):
+            _("<b>Line segment</b>: angle %3.2f&#176;, distance %s; with <b>Shift+Click</b> make a cusp node, <b>Enter</b> to finish the path");        
+        }
         this->_setAngleDistanceStatusMessage(p, 0, message);
     }
 }
 
+
 void PenTool::_setCtrl(Geom::Point const p, guint const state) {
     sp_canvas_item_show(this->c1);
     sp_canvas_item_show(this->cl1);
@@ -1224,7 +2115,6 @@ void PenTool::_setCtrl(Geom::Point const p, guint const state) {
         sp_canvas_item_hide(this->cl0);
         SP_CTRL(this->c1)->moveto(this->p[1]);
         this->cl1->setCoords(this->p[0], this->p[1]);
-
         this->_setAngleDistanceStatusMessage(p, 0, _("<b>Curve handle</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle"));
     } else if ( this->npoints == 5 ) {
         this->p[4] = p;
@@ -1246,6 +2136,8 @@ void PenTool::_setCtrl(Geom::Point const p, guint const state) {
         SP_CTRL(this->c1)->moveto(this->p[4]);
         this->cl1->setCoords(this->p[3], this->p[4]);
 
+
+
         gchar *message = is_symm ?
             _("<b>Curve handle, symmetric</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle, with <b>Shift</b> to move this handle only") :
             _("<b>Curve handle</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle, with <b>Shift</b> to move this handle only");
@@ -1260,11 +2152,14 @@ void PenTool::_finishSegment(Geom::Point const p, guint const state) {
         pen_last_paraxial_dir = this->nextParaxialDirection(p, this->p[0], state);
     }
 
-    ++this->num_clicks;
+    ++num_clicks;
+
 
     if (!this->red_curve->is_empty()) {
+        this->_bspline_spiro(state & GDK_SHIFT_MASK);
         this->green_curve->append_continuous(this->red_curve, 0.0625);
         SPCurve *curve = this->red_curve->copy();
+
         /// \todo fixme:
         SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), curve);
         curve->unref();
@@ -1286,15 +2181,19 @@ void PenTool::_finish(gboolean const closed) {
         return;
     }
 
+
     this->num_clicks = 0;
 
     this->_disableEvents();
 
     this->message_context->clear();
+
     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Drawing finished"));
 
+    // cancelate line without a created segment
     this->red_curve->reset();
     spdc_concat_colors_and_flush(this, closed);
+    this->overwriteCurve = NULL;
     this->sa = NULL;
     this->ea = NULL;
 
@@ -1343,7 +2242,7 @@ int PenTool::nextParaxialDirection(Geom::Point const &pt, Geom::Point const &ori
     //
     // num_clicks is not reliable because spdc_pen_finish_segment is sometimes called too early
     // (on first mouse release), in which case num_clicks immediately becomes 1.
-    // if (pc->num_clicks == 0) {
+    // if (this->num_clicks == 0) {
 
     if (this->green_curve->is_empty()) {
         // first mouse click
diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h
index 4dec7b4fe..98fd0a43e 100644
--- a/src/ui/tools/pen-tool.h
+++ b/src/ui/tools/pen-tool.h
@@ -49,6 +49,9 @@ public:
 
     bool polylines_only;
     bool polylines_paraxial;
+    // propiety which saves if Spiro mode is active or not
+    bool spiro;
+    bool bspline;
     int num_clicks;
 
     unsigned int expecting_clicks_for_LPE; // if positive, finish the path after this many clicks
@@ -85,6 +88,34 @@ private:
 	bool _handleButtonRelease(GdkEventButton const &revent);
 	bool _handle2ButtonPress(GdkEventButton const &bevent);
 	bool _handleKeyPress(GdkEvent *event);
+    //adds spiro & bspline modes
+    void _pen_context_set_mode(guint mode);
+    //this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro
+    void _bspline_spiro_color();
+    //creates a node in bspline or spiro modes
+    void _bspline_spiro(bool shift);
+    //creates a node in bspline or spiro modes
+    void _bspline_spiro_on();
+    //creates a CUSP node
+    void _bspline_spiro_off();
+    //continues the existing curve in bspline or spiro mode
+    void _bspline_spiro_start_anchor(bool shift);
+    //continues the existing curve with the union node in bspline or spiro modes
+    void _bspline_spiro_start_anchor_on();
+    //continues an existing curve with the union node in CUSP mode
+    void _bspline_spiro_start_anchor_off();
+    //modifies the "red_curve" when it detects movement
+    void _bspline_spiro_motion(bool shift);
+    //closes the curve with the last node in bspline or spiro mode
+    void _bspline_spiro_end_anchor_on();
+    //closes the curve with the last node in CUSP mode
+    void _bspline_spiro_end_anchor_off();
+    //CHECK: join all the curves "in game" and we call doEffect function
+    void _bspline_spiro_build();
+    //function bspline cloned from lpe-bspline.cpp
+    void _bspline_doEffect(SPCurve * curve);
+    //function spiro cloned from lpe-spiro.cpp
+    void _spiro_doEffect(SPCurve * curve);
 
 	void _setInitialPoint(Geom::Point const p);
 	void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0);
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index fb4e82c32..3ea2ae843 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -23,7 +23,7 @@
 #include "desktop-handles.h"
 #include "selection.h"
 #include "selection-chemistry.h"
-#include "draw-anchor.h"
+#include "ui/draw-anchor.h"
 #include "message-stack.h"
 #include "message-context.h"
 #include "sp-path.h"
@@ -43,7 +43,7 @@
 #include "display/sp-canvas.h"
 #include "display/curve.h"
 #include "livarot/Path.h"
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 #include "ui/tool/event-utils.h"
 
 namespace Inkscape {
@@ -200,6 +200,7 @@ bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
                 }
                 if (anchor) {
                     p = anchor->dp;
+                    this->overwriteCurve = anchor->curve;
                     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Continuing selected path"));
                 } else {
                     m.setup(desktop);
@@ -301,7 +302,7 @@ bool PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
 
                 if ( this->npoints != 0) { // buttonpress may have happened before we entered draw context!
                     if (this->ps.empty()) {
-                        // Only in freehand mode we have to add the first point also to pc->ps (apparently)
+                        // Only in freehand mode we have to add the first point also to this->ps (apparently)
                         // - We cannot add this point in spdc_set_startpoint, because we only need it for freehand
                         // - We cannot do this in the button press handler because at that point we don't know yet
                         //   wheter we're going into freehand mode or not
@@ -640,6 +641,9 @@ void PencilTool::_interpolate() {
         return;
     }
 
+    using Geom::X;
+    using Geom::Y;
+
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double const tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0) * 0.4;
     double const tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
@@ -661,10 +665,21 @@ void PencilTool::_interpolate() {
 
     if (n_segs > 0) {
         /* Fit and draw and reset state */
-        this->green_curve->moveto(b[0]);
 
+        this->green_curve->moveto(b[0]);
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
         for (int c = 0; c < n_segs; c++) {
-            this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
+            // if we are in BSpline we modify the trace to create adhoc nodes 
+            if(mode == 2){
+                Geom::Point BP = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]);
+                BP = Geom::Point(BP[X] + 0.0001,BP[Y] + 0.0001);
+                Geom::Point CP = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]);
+                CP = Geom::Point(CP[X] + 0.0001,CP[Y] + 0.0001);
+                this->green_curve->curveto(BP,CP,b[4*c+3]);
+            }else{
+                this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
+            }
         }
 
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->green_curve);
@@ -788,6 +803,7 @@ void PencilTool::_fitAndSplit() {
     g_assert(is_zero(this->req_tangent)
              || is_unit_vector(this->req_tangent));
     Geom::Point const tHatEnd(0, 0);
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     int const n_segs = Geom::bezier_fit_cubic_full(b, NULL, this->p, this->npoints,
                                                 this->req_tangent, tHatEnd,
                                                 tolerance_sq, 1);
@@ -795,9 +811,22 @@ void PencilTool::_fitAndSplit() {
          && unsigned(this->npoints) < G_N_ELEMENTS(this->p) )
     {
         /* Fit and draw and reset state */
+
         this->red_curve->reset();
         this->red_curve->moveto(b[0]);
-        this->red_curve->curveto(b[1], b[2], b[3]);
+        using Geom::X;
+        using Geom::Y;
+            // if we are in BSpline we modify the trace to create adhoc nodes
+        guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+        if(mode == 2){
+            Geom::Point B = b[0] + (1./3)*(b[3] - b[0]);
+            B = Geom::Point(B[X] + 0.0001,B[Y] + 0.0001);
+            Geom::Point C = b[3] + (1./3)*(b[0] - b[3]);
+            C = Geom::Point(C[X] + 0.0001,C[Y] + 0.0001);
+            this->red_curve->curveto(B,C,b[3]);
+        }else{
+            this->red_curve->curveto(b[1], b[2], b[3]);
+        }
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
         this->red_curve_is_valid = true;
     } else {
@@ -826,6 +855,13 @@ void PencilTool::_fitAndSplit() {
         /// \todo fixme:
         SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), curve);
         curve->unref();
+
+        this->highlight_color = SP_ITEM(this->desktop->currentLayer())->highlight_color();
+        if((unsigned int)prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff) == this->highlight_color){
+            this->green_color = 0x00ff007f;
+        } else {
+            this->green_color = this->highlight_color;
+        }
         sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
         this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
diff --git a/src/ui/tools/rect-tool.cpp b/src/ui/tools/rect-tool.cpp
index 39f422c1a..de91dcff4 100644
--- a/src/ui/tools/rect-tool.cpp
+++ b/src/ui/tools/rect-tool.cpp
@@ -40,13 +40,13 @@
 #include "xml/node-event-vector.h"
 #include "preferences.h"
 #include "context-fns.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "verbs.h"
 #include "display/sp-canvas-item.h"
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -102,8 +102,8 @@ RectTool::~RectTool() {
  * destroys old and creates new knotholder.
  */
 void RectTool::selection_changed(Inkscape::Selection* selection) {
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 }
 
 void RectTool::setup() {
@@ -113,7 +113,7 @@ void RectTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     this->sel_changed_connection.disconnect();
diff --git a/src/ui/tools/select-tool.cpp b/src/ui/tools/select-tool.cpp
index 21f37e83d..21459e5d0 100644
--- a/src/ui/tools/select-tool.cpp
+++ b/src/ui/tools/select-tool.cpp
@@ -41,7 +41,7 @@
 #include "desktop-handles.h"
 #include "sp-root.h"
 #include "preferences.h"
-#include "tools-switch.h"
+#include "ui/tools-switch.h"
 #include "message-stack.h"
 #include "selection-describer.h"
 #include "seltrans.h"
@@ -49,7 +49,7 @@
 #include "display/sp-canvas.h"
 #include "display/sp-canvas-item.h"
 #include "display/drawing-item.h"
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 using Inkscape::DocumentUndo;
 
diff --git a/src/ui/tools/select-tool.h b/src/ui/tools/select-tool.h
index edc4069a2..5af99a56a 100644
--- a/src/ui/tools/select-tool.h
+++ b/src/ui/tools/select-tool.h
@@ -13,7 +13,6 @@
  */
 
 #include "ui/tools/tool-base.h"
-#include <gtk/gtk.h>
 
 #define SP_SELECT_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::SelectTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_SELECT_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::SelectTool*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
diff --git a/src/ui/tools/spiral-tool.cpp b/src/ui/tools/spiral-tool.cpp
index 5ae229df8..18c3e4e2d 100644
--- a/src/ui/tools/spiral-tool.cpp
+++ b/src/ui/tools/spiral-tool.cpp
@@ -39,13 +39,13 @@
 #include "xml/node-event-vector.h"
 #include "preferences.h"
 #include "context-fns.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "verbs.h"
 #include "display/sp-canvas-item.h"
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -104,8 +104,8 @@ SpiralTool::~SpiralTool() {
  * destroys old and creates new knotholder.
  */
 void SpiralTool::selection_changed(Inkscape::Selection *selection) {
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 }
 
 void SpiralTool::setup() {
@@ -119,7 +119,7 @@ void SpiralTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     Inkscape::Selection *selection = sp_desktop_selection(this->desktop);
diff --git a/src/ui/tools/spiral-tool.h b/src/ui/tools/spiral-tool.h
index 416aeb7e4..add92342d 100644
--- a/src/ui/tools/spiral-tool.h
+++ b/src/ui/tools/spiral-tool.h
@@ -15,17 +15,15 @@
  * Released under GNU GPL
  */
 
-#include <gtk/gtk.h>
-#include <stddef.h>
-#include <sigc++/sigc++.h>
+#include <sigc++/connection.h>
 #include <2geom/point.h>
 #include "ui/tools/tool-base.h"
 
-#include "sp-spiral.h"
-
 #define SP_SPIRAL_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::SpiralTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_SPIRAL_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::SpiralTool*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
 
+class SPSpiral;
+
 namespace Inkscape {
 namespace UI {
 namespace Tools {
diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp
index e15dbb59f..cdc608558 100644
--- a/src/ui/tools/spray-tool.cpp
+++ b/src/ui/tools/spray-tool.cpp
@@ -84,7 +84,7 @@ using namespace std;
 // Please enable again when working on 1.0
 #define ENABLE_SPRAY_MODE_SINGLE_PATH
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/star-tool.cpp b/src/ui/tools/star-tool.cpp
index 68f998920..7604ba04e 100644
--- a/src/ui/tools/star-tool.cpp
+++ b/src/ui/tools/star-tool.cpp
@@ -41,7 +41,7 @@
 #include "xml/repr.h"
 #include "xml/node-event-vector.h"
 #include "context-fns.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "verbs.h"
 #include "display/sp-canvas-item.h"
 
@@ -49,7 +49,7 @@
 
 using Inkscape::DocumentUndo;
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
@@ -112,8 +112,8 @@ StarTool::~StarTool() {
 void StarTool::selection_changed(Inkscape::Selection* selection) {
     g_assert (selection != NULL);
 
-    this->shape_editor->unset_item(SH_KNOTHOLDER);
-    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
+    this->shape_editor->unset_item();
+    this->shape_editor->set_item(selection->singleItem());
 }
 
 void StarTool::setup() {
@@ -129,7 +129,7 @@ void StarTool::setup() {
 
 	SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
 	if (item) {
-		this->shape_editor->set_item(item, SH_KNOTHOLDER);
+		this->shape_editor->set_item(item);
 	}
 
 	Inkscape::Selection *selection = sp_desktop_selection(this->desktop);
diff --git a/src/ui/tools/text-tool.cpp b/src/ui/tools/text-tool.cpp
index ac830fe6b..a72748733 100644
--- a/src/ui/tools/text-tool.cpp
+++ b/src/ui/tools/text-tool.cpp
@@ -40,7 +40,7 @@
 #include "rubberband.h"
 #include "selection-chemistry.h"
 #include "selection.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "sp-flowtext.h"
 #include "sp-namedview.h"
 #include "sp-text.h"
@@ -52,7 +52,7 @@
 #include "xml/node-event-vector.h"
 #include "xml/repr.h"
 #include <gtk/gtk.h>
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 using Inkscape::ControlManager;
 using Inkscape::DocumentUndo;
@@ -177,7 +177,7 @@ void TextTool::setup() {
 
     SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item && SP_IS_FLOWTEXT(item) && SP_FLOWTEXT(item)->has_internal_frame()) {
-        this->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item);
     }
 
     this->sel_changed_connection = sp_desktop_selection(desktop)->connectChangedFirst(
@@ -1411,10 +1411,10 @@ void TextTool::_selectionChanged(Inkscape::Selection *selection)
 
     ToolBase *ec = SP_EVENT_CONTEXT(this);
 
-    ec->shape_editor->unset_item(SH_KNOTHOLDER);
+    ec->shape_editor->unset_item();
     SPItem *item = selection->singleItem();
     if (item && SP_IS_FLOWTEXT(item) && SP_FLOWTEXT(item)->has_internal_frame()) {
-        ec->shape_editor->set_item(item, SH_KNOTHOLDER);
+        ec->shape_editor->set_item(item);
     }
 
     if (this->text && (item != this->text)) {
diff --git a/src/ui/tools/text-tool.h b/src/ui/tools/text-tool.h
index ca2b3d19a..289ee180d 100644
--- a/src/ui/tools/text-tool.h
+++ b/src/ui/tools/text-tool.h
@@ -14,10 +14,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-/*  #include <gdk/gdkic.h> */
-#include <stddef.h>
-#include <sigc++/sigc++.h>
-#include <gtk/gtk.h>
+#include <sigc++/connection.h>
 
 #include "ui/tools/tool-base.h"
 #include <2geom/point.h>
@@ -26,6 +23,8 @@
 #define SP_TEXT_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::TextTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_TEXT_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::TextTool*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
 
+typedef struct _GtkIMContext GtkIMContext;
+
 struct SPCtrlLine;
 
 namespace Inkscape {
diff --git a/src/ui/tools/tool-base.cpp b/src/ui/tools/tool-base.cpp
index 1c1e8a17a..37ca5eeea 100644
--- a/src/ui/tools/tool-base.cpp
+++ b/src/ui/tools/tool-base.cpp
@@ -44,9 +44,9 @@
 #include "desktop-style.h"
 #include "sp-namedview.h"
 #include "selection.h"
-#include "interface.h"
+#include "ui/interface.h"
 #include "macros.h"
-#include "tools-switch.h"
+#include "ui/tools-switch.h"
 #include "preferences.h"
 #include "message-context.h"
 #include "gradient-drag.h"
@@ -55,10 +55,11 @@
 #include "selcue.h"
 #include "ui/tools/lpe-tool.h"
 #include "ui/tool/control-point.h"
-#include "shape-editor.h"
+#include "ui/shape-editor.h"
 #include "sp-guide.h"
 #include "color.h"
 #include "knot.h"
+#include "knot-ptr.h"
 
 // globals for temporary switching to selector by space
 static bool selector_toggled = FALSE;
@@ -1360,6 +1361,7 @@ gboolean sp_event_context_snap_watchdog_callback(gpointer data) {
         break;
     case DelayedSnapEvent::KNOT_HANDLER: {
         gpointer knot = dse->getItem2();
+        check_if_knot_deleted(knot);
         if (knot && SP_IS_KNOT(knot)) {
             sp_knot_handler_request_position(dse->getEvent(), SP_KNOT(knot));
         }
diff --git a/src/ui/tools/tool-base.h b/src/ui/tools/tool-base.h
index b27de9030..7a6ab83e7 100644
--- a/src/ui/tools/tool-base.h
+++ b/src/ui/tools/tool-base.h
@@ -30,7 +30,6 @@ namespace Glib {
 class GrDrag;
 class SPDesktop;
 class SPItem;
-class ShapeEditor;
 
 namespace Inkscape {
     class MessageContext;
@@ -42,6 +41,9 @@ namespace Inkscape {
 
 namespace Inkscape {
 namespace UI {
+
+class ShapeEditor;
+
 namespace Tools {
 
 class ToolBase;
diff --git a/src/ui/tools/tweak-tool.cpp b/src/ui/tools/tweak-tool.cpp
index 571a17b70..f56975de2 100644
--- a/src/ui/tools/tweak-tool.cpp
+++ b/src/ui/tools/tweak-tool.cpp
@@ -91,7 +91,7 @@ using Inkscape::DocumentUndo;
 
 #define DYNA_MIN_WIDTH 1.0e-6
 
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/zoom-tool.cpp b/src/ui/tools/zoom-tool.cpp
index 9f99cfe2e..b3fb78c8f 100644
--- a/src/ui/tools/zoom-tool.cpp
+++ b/src/ui/tools/zoom-tool.cpp
@@ -25,7 +25,7 @@
 #include "selection-chemistry.h"
 
 #include "ui/tools/zoom-tool.h"
-#include "tool-factory.h"
+#include "ui/tool-factory.h"
 
 namespace Inkscape {
 namespace UI {