diff --git a/plugins/tools/selectiontools/CMakeLists.txt b/plugins/tools/selectiontools/CMakeLists.txt
index b00dfbc0d8..c94bc3ef02 100644
--- a/plugins/tools/selectiontools/CMakeLists.txt
+++ b/plugins/tools/selectiontools/CMakeLists.txt
@@ -1,41 +1,40 @@
 set(kritaselectiontools_SOURCES
     selection_tools.cc
     kis_tool_select_rectangular.cc
     kis_tool_select_polygonal.cc
     kis_tool_select_elliptical.cc
     kis_tool_select_contiguous.cc
     kis_tool_select_outline.cc
     kis_tool_select_path.cc
     kis_tool_select_similar.cc
     kis_selection_modifier_mapper.cc
     KisMagneticWorker.cc
     KisToolSelectMagnetic.cc
     kis_tool_select_guided.cpp
     kis_tool_select_guided_options_widget.cpp
-    tool_selectguided.cpp
 )
 
 ki18n_wrap_ui(kritaselectiontools_SOURCES kis_tool_select_guided_options_widget.ui)
 
 qt5_add_resources(kritaselectiontools_SOURCES selectiontools.qrc)
 
 add_library(kritaselectiontools MODULE ${kritaselectiontools_SOURCES})
 
 generate_export_header(kritaselectiontools BASE_NAME kritaselectiontools)
 
 target_link_libraries(kritaselectiontools kritaui kritabasicflakes kritaimage)
 
 install(TARGETS kritaselectiontools  DESTINATION ${KRITA_PLUGIN_INSTALL_DIR})
 
 install( FILES
         KisToolSelectPolygonal.action
         KisToolSelectElliptical.action
         KisToolSelectSimilar.action
         KisToolSelectContiguous.action
         KisToolSelectRectangular.action
         KisToolSelectOutline.action
         KisToolSelectPath.action
         KisToolSelectMagnetic.action
         KisToolSelectGuided.action
     DESTINATION  ${DATA_INSTALL_DIR}/krita/actions
 )
diff --git a/plugins/tools/selectiontools/kis_tool_select_guided.cpp b/plugins/tools/selectiontools/kis_tool_select_guided.cpp
index 974e44d9b7..dd764123b5 100644
--- a/plugins/tools/selectiontools/kis_tool_select_guided.cpp
+++ b/plugins/tools/selectiontools/kis_tool_select_guided.cpp
@@ -1,149 +1,151 @@
 #include "kis_tool_select_guided.h"
 
 #include "QApplication"
 #include "QPainterPath"
 
 #include <klocalizedstring.h>
 #include <KoColor.h>
 #include <KisViewManager.h>
 #include "kis_canvas2.h"
 #include "kis_cursor.h"
 #include "kis_painter.h"
 #include "kis_paintop_preset.h"
 
 #include "kundo2magicstring.h"
 #include "kundo2stack.h"
 #include "commands_new/kis_transaction_based_command.h"
 #include "kis_transaction.h"
 
 #include "kis_processing_applicator.h"
 #include "kis_datamanager.h"
 
 #include "KoColorSpaceRegistry.h"
 
 #include "kis_tool_select_guided_options_widget.h"
 #include "libs/image/kis_paint_device_debug_utils.h"
 
 #include "kis_paint_layer.h"
 #include "kis_algebra_2d.h"
 #include <QApplication>
 #include <QPainter>
 #include <QWidget>
 #include <QPainterPath>
 #include <QLayout>
 #include <QVBoxLayout>
 #include <QBitArray>
 
 #include <kis_selection_options.h>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 
 #include <KoPointerEvent.h>
 #include <KoShapeController.h>
 #include <KoPathShape.h>
 #include <KoColorSpace.h>
 #include <KoCompositeOp.h>
 #include <KoViewConverter.h>
 
 #include <kis_layer.h>
 #include <kis_selection_options.h>
 #include <kis_cursor.h>
 #include <kis_image.h>
 
 #include "kis_painter.h"
 #include <brushengine/kis_paintop_registry.h>
 #include "canvas/kis_canvas2.h"
 #include "kis_pixel_selection.h"
 #include "kis_selection_tool_helper.h"
 #include "kis_tool_select_guided_options_widget.h"
 
 #include "kis_algebra_2d.h"
 
 #include "KisHandlePainterHelper.h"
 
 #include <kis_slider_spin_box.h>
 
 #include <KoColorSpace.h>
 #include <KoChannelInfo.h>
 #include <KoColor.h>
 #include <kis_painter.h>
 #include <kis_paint_device.h>
 #include <kis_paint_layer.h>
 #include <kis_group_layer.h>
 
 #include <kis_slider_spin_box.h>
 
 
 KisToolSelectGuided::KisToolSelectGuided(KoCanvasBase *canvas)
     : KisToolSelect(canvas,
                     KisCursor::crossCursor(),
                     i18n("Guided Selection")),
     m_finished(false), m_filterRadius(3), m_epsilon(70)
 { }
 
+struct KisToolSelectGuided::Private {
+    KisToolSelectGuidedOptionsWidget *optionsWidget = nullptr;
+};
+
 /*void KisToolSelectGuided::GuidedSelectGenerate()
 {
 	KisCanvas2 *kisCanvas = dynamic_cast<KisCanvas2 *>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     kisCanvas->updateCanvas();
     setMode(KisTool::HOVER_MODE);
     
     if (mode == PIXEL_SELECTION){
 		KisPaintDeviceSP image = KisPaintDeviceSP(new KisPaintDevice(currentImage()->projection()));
 		
 		image.ConvertTo(KoColorSpaceRegistry::instance()->rgb32());
 		
 		KisLodTransformScalar t(image);
 		const qreal BoxBlurAmount = t.scale(m_filterEpsilon ? m_filterEpsilon.toDouble() : 1.0);
 		QRect applyRect(QPoint(0, 0), image.width(),image.height());
 		const QRect boxNeedRect = this->neededRect(applyRect, config, originalimage->defaultBounds()->currentLevelOfDetail());
 
 		KisSequentialConstIterator it(imageDev, QRect(0, 0, image.width(), image.height()));
 
         for (int y = 0; y < image.height(); y++) {
             for (int x = 0; x < image.width(); x++) {
                 it.nextPixel();
                 const quint8* pixel = it.rawDataConst();
                 for (int chan = 0; chan < 4; ++chan) {
                     image &img = image[chan];
                     *(img.scanLine(y) + x) = cs->scaleToU8(pixel, chan);
                 }
             }
 		}		
 	}
 }
 
 QRect KisToolSelectGuided::neededRect(const QRect & rect, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     const int halfSize = m_filterRadius ? KisGaussianKernel::kernelSizeFromRadius(t.scale(m_filterRadius.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize * 2, -halfSize * 2, halfSize * 2, halfSize * 2);
 }
 
 QRect KisToolSelectGuided::changedRect(const QRect & rect, int lod) const
 {
     KisLodTransformScalar t(lod);
 
     const int halfSize = m_filterRadius ? KisGaussianKernel::kernelSizeFromRadius(t.scale(m_filterRadius.toFloat())) / 2 : 5;
 
     return rect.adjusted( -halfSize, -halfSize, halfSize, halfSize);
 }*/
 
 void KisToolSelectGuided::paint(QPainter& gc, const KoViewConverter &converter)
 {
 }
 
 QWidget * KisToolSelectGuided::createOptionWidget()
 {
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
 
     m_d->optionsWidget = new KisToolSelectGuidedOptionsWidget(kiscanvas->viewManager()->canvasResourceProvider(), 0);
     m_d->optionsWidget->setObjectName(toolId() + "option widget");
 
     return m_d->optionsWidget;
 }
-
-
diff --git a/plugins/tools/selectiontools/kis_tool_select_guided.h b/plugins/tools/selectiontools/kis_tool_select_guided.h
index 294142dd08..cd7d924920 100644
--- a/plugins/tools/selectiontools/kis_tool_select_guided.h
+++ b/plugins/tools/selectiontools/kis_tool_select_guided.h
@@ -1,78 +1,82 @@
 #ifndef KIS_TOOL_SELECT_GUIDED_H_
 #define KIS_TOOL_SELECT_GUIDED_H_
 
 #include <QPoint>
 #include <QPainterPath>
+#include <QScopedPointer>
+
 #include "kis_tool_paint.h"
 #include "KisSelectionToolFactoryBase.h"
+#include "KisToolPaintFactoryBase.h"
+
 #include <kis_signal_compressor.h>
 #include <flake/kis_node_shape.h>
 #include <kis_icon.h>
 #include <QKeySequence>
+
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <KoIcon.h>
+
 #include <kis_tool_select_base.h>
 #include "selection_tools.h"
-#include "tool_selectguided.h"
 #include "kis_selection_tool_config_widget_helper.h"
+
 #include <QMenu>
 
+class KActionCollection;
 class QPainterPath;
 class KoCanvasBase;
 
 class KisToolSelectGuided : public KisToolSelect
 {
     Q_OBJECT
 
 public:
     KisToolSelectGuided(KoCanvasBase * canvas);
     ~KisToolSelectGuided() override = default;
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     QWidget * createOptionWidget() override;
 public Q_SLOTS:
     int getKernelRadius(void);
     qreal getEpsilon(void);
     bool getSelectActive(void);
 
 protected:
 
 private:
-    QPainterPath m_paintPath;
+    //const QRect& applyRect;
+    //const QRect& neededRect;
+    struct Private;
     bool m_finished;
     int m_filterRadius;
     qreal m_epsilon;
     bool activate_selection_painting;
-
-private:
-    //const QRect& applyRect;
-    //const QRect& neededRect;
-    struct Private;
     const QScopedPointer<Private> m_d;
 };
 
 class KisToolSelectGuidedFactory : public KisSelectionToolFactoryBase
 {
 public:
     KisToolSelectGuidedFactory()
         : KisSelectionToolFactoryBase("KisToolSelectGuided")
     {
         setToolTip(i18n("Guided Selection Tool"));
         setSection(TOOL_TYPE_SELECTION);
         setIconName(koIconNameCStr("tool_guided_selection"));
         setPriority(9);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
     ~KisToolSelectGuidedFactory() override { }
 
     KoToolBase * createTool(KoCanvasBase *canvas) override
     {
         return new KisToolSelectGuided(canvas);
     }
 };
 
 
 #endif // KIS_TOOL_SELECT_GUIDED_H
diff --git a/plugins/tools/selectiontools/tool_selectguided.cpp b/plugins/tools/selectiontools/tool_selectguided.cpp
deleted file mode 100644
index d1896a8026..0000000000
--- a/plugins/tools/selectiontools/tool_selectguided.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "tool_selectguided.h"
-#include <QStringList>
-
-#include <kis_debug.h>
-#include <kpluginfactory.h>
-
-#include <kis_tool.h>
-#include <KoToolRegistry.h>
-
-#include "kis_paint_device.h"
-#include "kis_tool_select_guided.h"
-
-
-K_PLUGIN_FACTORY_WITH_JSON(DefaultToolsFactory, "kritatoolselectguided.json", registerPlugin<ToolSelectGuided>();)
-
-
-ToolSelectGuided::ToolSelectGuided(QObject *parent, const QVariantList &)
-    : QObject(parent)
-{
-    KoToolRegistry::instance()->add(new KisToolSelectGuidedFactory());
-}
-
-ToolSelectGuided::~ToolSelectGuided()
-{
-}
diff --git a/plugins/tools/selectiontools/tool_selectguided.h b/plugins/tools/selectiontools/tool_selectguided.h
deleted file mode 100644
index dd598f285e..0000000000
--- a/plugins/tools/selectiontools/tool_selectguided.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef TOOL_SELECTGUIDED_H_
-#define TOOL_SELECTGUIDED_H_
-
-#include <QObject>
-#include <QVariant>
-
-class ToolSelectGuided : public QObject
-{
-    Q_OBJECT
-public:
-    ToolSelectGuided(QObject *parent, const QVariantList &);
-    ~ToolSelectGuided() override;
-
-};
-
-#endif // TOOL_SELECTGUIDED_H_