diff --git a/plugins/tools/selectiontools/kis_tool_select_path.cc b/plugins/tools/selectiontools/kis_tool_select_path.cc
index d00bb19605..b70e81dffe 100644
--- a/plugins/tools/selectiontools/kis_tool_select_path.cc
+++ b/plugins/tools/selectiontools/kis_tool_select_path.cc
@@ -1,192 +1,207 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_tool_select_path.h"
 
 #include <KoPathShape.h>
 
 #include "kis_cursor.h"
 #include "kis_image.h"
 #include "kis_painter.h"
 #include "kis_selection_options.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 #include <KisView.h>
 
 
 KisToolSelectPath::KisToolSelectPath(KoCanvasBase * canvas)
     : KisToolSelectBase<KisDelegatedSelectPathWrapper>(canvas,
                                                        KisCursor::load("tool_polygonal_selection_cursor.png", 6, 6),
                                                        i18n("Select path"),
                                                        new __KisToolSelectPathLocalTool(canvas, this))
 {
 }
 
 void KisToolSelectPath::requestStrokeEnd()
 {
     localTool()->endPathWithoutLastPoint();
 }
 
 void KisToolSelectPath::requestStrokeCancellation()
 {
     localTool()->cancelPath();
 }
 
-void KisToolSelectPath::mousePressEvent(KoPointerEvent* event)
-{
-    if (!selectionEditable()) return;
-    DelegatedSelectPathTool::mousePressEvent(event);
-}
-
 // Install an event filter to catch right-click events.
 // This code is duplicated in kis_tool_path.cc
 bool KisToolSelectPath::eventFilter(QObject *obj, QEvent *event)
 {
     Q_UNUSED(obj);
     if (event->type() == QEvent::MouseButtonPress ||
             event->type() == QEvent::MouseButtonDblClick) {
         QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
         if (mouseEvent->button() == Qt::RightButton) {
             localTool()->removeLastPoint();
             return true;
         }
     } else if (event->type() == QEvent::TabletPress) {
         QTabletEvent *tabletEvent = static_cast<QTabletEvent*>(event);
         if (tabletEvent->button() == Qt::RightButton) {
             localTool()->removeLastPoint();
             return true;
         }
     }
     return false;
 }
 
 QList<QPointer<QWidget> > KisToolSelectPath::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgetsList =
             DelegatedSelectPathTool::createOptionWidgets();
     QList<QPointer<QWidget> > filteredWidgets;
     Q_FOREACH (QWidget* widget, widgetsList) {
         if (widget->objectName() != "Stroke widget") {
             filteredWidgets.push_back(widget);
         }
     }
     return filteredWidgets;
 }
 
 void KisDelegatedSelectPathWrapper::beginPrimaryAction(KoPointerEvent *event) {
-    mousePressEvent(event);
+    DelegatedSelectPathTool::mousePressEvent(event);
 }
 
 void KisDelegatedSelectPathWrapper::continuePrimaryAction(KoPointerEvent *event){
-    mouseMoveEvent(event);
+    DelegatedSelectPathTool::mouseMoveEvent(event);
 }
 
 void KisDelegatedSelectPathWrapper::endPrimaryAction(KoPointerEvent *event) {
-    mouseReleaseEvent(event);
+    DelegatedSelectPathTool::mouseReleaseEvent(event);
+}
+
+void KisDelegatedSelectPathWrapper::beginPrimaryDoubleClickAction(KoPointerEvent *event)
+{
+    DelegatedSelectPathTool::mouseDoubleClickEvent(event);
+}
+
+void KisDelegatedSelectPathWrapper::mousePressEvent(KoPointerEvent *event)
+{
+    // this event will be forwarded using beginPrimaryAction
+    Q_UNUSED(event);
+}
+
+void KisDelegatedSelectPathWrapper::mouseMoveEvent(KoPointerEvent *event)
+{
+    DelegatedSelectPathTool::mouseMoveEvent(event);
+}
+
+void KisDelegatedSelectPathWrapper::mouseReleaseEvent(KoPointerEvent *event)
+{
+    // this event will be forwarded using continuePrimaryAction
+    Q_UNUSED(event);
+}
+
+void KisDelegatedSelectPathWrapper::mouseDoubleClickEvent(KoPointerEvent *event)
+{
+    // this event will be forwarded using endPrimaryAction
+    Q_UNUSED(event);
 }
 
 bool KisDelegatedSelectPathWrapper::hasUserInteractionRunning() const
 {
-    /**
-     * KoCreatePathTool doesn't support moving interventions from KisToolselectBase,
-     * because it doesn't use begin/continue/endPrimaryAction and uses direct event
-     * handling instead.
-     *
-     * TODO: refactor KoCreatePathTool and port it to action infrastructure
-     */
-    return true;
+    return localTool()->pathStarted();
 }
 
 
 __KisToolSelectPathLocalTool::__KisToolSelectPathLocalTool(KoCanvasBase * canvas, KisToolSelectPath* parentTool)
     : KoCreatePathTool(canvas), m_selectionTool(parentTool)
 {
     setEnableClosePathShortcut(false);
 }
 
 void __KisToolSelectPathLocalTool::paintPath(KoPathShape &pathShape, QPainter &painter, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (!kisCanvas)
         return;
 
     QTransform matrix;
     matrix.scale(kisCanvas->image()->xRes(), kisCanvas->image()->yRes());
     matrix.translate(pathShape.position().x(), pathShape.position().y());
     m_selectionTool->paintToolOutline(&painter, m_selectionTool->pixelToView(matrix.map(pathShape.outline())));
 }
 
 void __KisToolSelectPathLocalTool::addPathShape(KoPathShape* pathShape)
 {
     pathShape->normalize();
     pathShape->close();
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     if (!kisCanvas)
         return;
 
     KisImageWSP image = kisCanvas->image();
 
     KisSelectionToolHelper helper(kisCanvas, kundo2_i18n("Select by Bezier Curve"));
 
     const SelectionMode mode =
         helper.tryOverrideSelectionMode(kisCanvas->viewManager()->selection(),
                                         m_selectionTool->selectionMode(),
                                         m_selectionTool->selectionAction());
 
     if (mode == PIXEL_SELECTION) {
 
         KisPixelSelectionSP tmpSel = KisPixelSelectionSP(new KisPixelSelection());
 
         KisPainter painter(tmpSel);
         painter.setPaintColor(KoColor(Qt::black, tmpSel->colorSpace()));
         painter.setFillStyle(KisPainter::FillStyleForegroundColor);
         painter.setAntiAliasPolygonFill(m_selectionTool->antiAliasSelection());
         painter.setStrokeStyle(KisPainter::StrokeStyleNone);
 
         QTransform matrix;
         matrix.scale(image->xRes(), image->yRes());
         matrix.translate(pathShape->position().x(), pathShape->position().y());
 
         QPainterPath path = matrix.map(pathShape->outline());
         painter.fillPainterPath(path);
         tmpSel->setOutlineCache(path);
 
         helper.selectPixelSelection(tmpSel, m_selectionTool->selectionAction());
 
         delete pathShape;
     } else {
         helper.addSelectionShape(pathShape, m_selectionTool->selectionAction());
     }
 }
 
 void KisToolSelectPath::resetCursorStyle()
 {
     if (selectionAction() == SELECTION_ADD) {
         useCursor(KisCursor::load("tool_polygonal_selection_cursor_add.png", 6, 6));
     } else if (selectionAction() == SELECTION_SUBTRACT) {
         useCursor(KisCursor::load("tool_polygonal_selection_cursor_sub.png", 6, 6));
     } else {
         KisToolSelectBase<KisDelegatedSelectPathWrapper>::resetCursorStyle();
     }
 }
 
 
diff --git a/plugins/tools/selectiontools/kis_tool_select_path.h b/plugins/tools/selectiontools/kis_tool_select_path.h
index c4ac6dd8f3..9807ad93e2 100644
--- a/plugins/tools/selectiontools/kis_tool_select_path.h
+++ b/plugins/tools/selectiontools/kis_tool_select_path.h
@@ -1,111 +1,117 @@
 /*
  *  Copyright (c) 2007 Sven Langkamp <sven.langkamp@gmail.com>
  *  Copyright (c) 2015 Michael Abrahams <miabraha@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KIS_TOOL_SELECT_PATH_H_
 #define KIS_TOOL_SELECT_PATH_H_
 
 #include <KoCreatePathTool.h>
 #include <KisSelectionToolFactoryBase.h>
 #include "kis_tool_select_base.h"
 #include "kis_delegated_tool.h"
 
 #include <kis_icon.h>
 
 class KoCanvasBase;
 class KisToolSelectPath;
 
 
 class __KisToolSelectPathLocalTool : public KoCreatePathTool {
 public:
     __KisToolSelectPathLocalTool(KoCanvasBase *canvas, KisToolSelectPath *parentTool);
     void paintPath(KoPathShape &path, QPainter &painter, const KoViewConverter &converter) override;
     void addPathShape(KoPathShape* pathShape) override;
 
     using KoCreatePathTool::createOptionWidgets;
     using KoCreatePathTool::endPathWithoutLastPoint;
     using KoCreatePathTool::endPath;
     using KoCreatePathTool::cancelPath;
     using KoCreatePathTool::removeLastPoint;
 
 private:
     KisToolSelectPath* const m_selectionTool;
 };
 
 typedef KisDelegatedTool<KisTool, __KisToolSelectPathLocalTool,
 DeselectShapesActivationPolicy> DelegatedSelectPathTool;
 
 struct KisDelegatedSelectPathWrapper : public DelegatedSelectPathTool {
     KisDelegatedSelectPathWrapper(KoCanvasBase *canvas,
                                   const QCursor &cursor,
                                   KoToolBase *delegateTool)
         : DelegatedSelectPathTool(canvas, cursor, dynamic_cast<__KisToolSelectPathLocalTool*>(delegateTool))
     {
         Q_ASSERT(dynamic_cast<__KisToolSelectPathLocalTool*>(delegateTool));
     }
 
     // If an event is explicitly forwarded only as an action (e.g. shift-click is captured by "change size")
     // we will receive a primary action but no mousePressEvent.  Thus these events must be explicitly forwarded.
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
+    void beginPrimaryDoubleClickAction(KoPointerEvent *event) override;
+
+
+    void mousePressEvent(KoPointerEvent *event) override;
+    void mouseMoveEvent(KoPointerEvent *event) override;
+    void mouseReleaseEvent(KoPointerEvent *event) override;
+    void mouseDoubleClickEvent(KoPointerEvent *event) override;
 
     bool hasUserInteractionRunning() const;
 };
 
 
 class KisToolSelectPath : public KisToolSelectBase<KisDelegatedSelectPathWrapper>
 {
     Q_OBJECT
 public:
     KisToolSelectPath(KoCanvasBase * canvas);
-    void mousePressEvent(KoPointerEvent* event) override;
     bool eventFilter(QObject *obj, QEvent *event) override;
     void resetCursorStyle() override;
 
 protected:
     void requestStrokeCancellation() override;
     void requestStrokeEnd() override;
     friend class __KisToolSelectPathLocalTool;
     QList<QPointer<QWidget> > createOptionWidgets() override;
 };
 
 class KisToolSelectPathFactory : public KisSelectionToolFactoryBase
 {
 public:
     KisToolSelectPathFactory()
         : KisSelectionToolFactoryBase("KisToolSelectPath") {
         setToolTip(i18n("Bezier Curve Selection Tool"));
         setSection(TOOL_TYPE_SELECTION);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setIconName(koIconNameCStr("tool_path_selection"));
         setPriority(6);
     }
 
     ~KisToolSelectPathFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolSelectPath(canvas);
     }
 
 
 };
 
 
 
 #endif // KIS_TOOL_SELECT_PATH_H_