diff --git a/plugins/tools/selectiontools/kis_tool_select_magnetic.cc b/plugins/tools/selectiontools/kis_tool_select_magnetic.cc
index 6c5910ff45..0c609a6fcf 100644
--- a/plugins/tools/selectiontools/kis_tool_select_magnetic.cc
+++ b/plugins/tools/selectiontools/kis_tool_select_magnetic.cc
@@ -1,208 +1,208 @@
 /*
  *  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_magnetic.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>
 
 
 KisToolSelectMagnetic::KisToolSelectMagnetic(KoCanvasBase * canvas)
     : KisToolSelectBase<KisDelegatedSelectMagneticWrapper>(canvas,
                                                        KisCursor::load("tool_polygonal_selection_cursor.png", 6, 6),
                                                        i18n("Select path"),
-                                                           dynamic_cast<KisTool*> (new __KisToolSelectMagneticLocalTool(canvas, this)))
+                                                           (KisTool*) (new __KisToolSelectMagneticLocalTool(canvas, this)))
 {
 }
 
 void KisToolSelectMagnetic::requestStrokeEnd()
 {
     localTool()->endPathWithoutLastPoint();
 }
 
 void KisToolSelectMagnetic::requestStrokeCancellation()
 {
     localTool()->cancelPath();
 }
 
 void KisToolSelectMagnetic::mousePressEvent(KoPointerEvent* event)
 {
     if (!selectionEditable()) return;
     DelegatedSelectMagneticTool::mousePressEvent(event);
 }
 
 // Install an event filter to catch right-click events.
 // This code is duplicated in kis_tool_path.cc
 bool KisToolSelectMagnetic::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> > KisToolSelectMagnetic::createOptionWidgets()
 {
     QList<QPointer<QWidget> > widgetsList =
             DelegatedSelectMagneticTool::createOptionWidgets();
     QList<QPointer<QWidget> > filteredWidgets;
     Q_FOREACH (QWidget* widget, widgetsList) {
         if (widget->objectName() != "Stroke widget") {
             filteredWidgets.push_back(widget);
         }
     }
     return filteredWidgets;
 }
 
 void KisDelegatedSelectMagneticWrapper::beginPrimaryAction(KoPointerEvent *event) {
     mousePressEvent(event);
 }
 
 void KisDelegatedSelectMagneticWrapper::continuePrimaryAction(KoPointerEvent *event){
     mouseMoveEvent(event);
 }
 
 void KisDelegatedSelectMagneticWrapper::endPrimaryAction(KoPointerEvent *event) {
     mouseReleaseEvent(event);
 }
 
 bool KisDelegatedSelectMagneticWrapper::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;
 }
 
 
 __KisToolSelectMagneticLocalTool::__KisToolSelectMagneticLocalTool(KoCanvasBase * canvas, KisToolSelectMagnetic* parentTool)
     : KoCreatePathTool(canvas), m_selectionTool(parentTool)
 {
     setEnableClosePathShortcut(false);
 }
 
 void __KisToolSelectMagneticLocalTool::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());
 
     qreal zoomX, zoomY;
     kisCanvas->viewConverter()->zoom(&zoomX, &zoomY);
     Q_ASSERT(qFuzzyCompare(zoomX, zoomY));
 
     qreal width = 25*2;
     width *= zoomX/(kisCanvas->image()->xRes());
 
     paintOutline(&painter, m_selectionTool->pixelToView(matrix.map(pathShape.outline())), width);
 }
 
 void __KisToolSelectMagneticLocalTool::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 __KisToolSelectMagneticLocalTool::paintOutline(QPainter *painter, const QPainterPath &path, qreal width)
 {
     painter->save();
     painter->setOpacity(.3);
     painter->setPen(QPen(QColor(128, 128, 128), width));
     painter->drawPath(path);
     m_selectionTool->updateCanvasViewRect(path.controlPointRect().adjusted(-width, -width, width, width));
     painter->restore();
 }
 
 void KisToolSelectMagnetic::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<KisDelegatedSelectMagneticWrapper>::resetCursorStyle();
     }
 }
diff --git a/plugins/tools/selectiontools/kis_tool_select_magnetic.h b/plugins/tools/selectiontools/kis_tool_select_magnetic.h
index 54075634d3..604b4766ed 100644
--- a/plugins/tools/selectiontools/kis_tool_select_magnetic.h
+++ b/plugins/tools/selectiontools/kis_tool_select_magnetic.h
@@ -1,115 +1,115 @@
 /*
  *  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_MAGNETIC_H_
 #define KIS_TOOL_SELECT_MAGNETIC_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 KisToolSelectMagnetic;
 
 
 class __KisToolSelectMagneticLocalTool : public KoCreatePathTool {
 public:
     __KisToolSelectMagneticLocalTool(KoCanvasBase * canvas, KisToolSelectMagnetic* parentTool);
     void paintPath(KoPathShape &path, QPainter &painter, const KoViewConverter &converter) override;
     void addPathShape(KoPathShape* pathShape) override;
 
     friend class KisToolSelectMagnetic;
 
     using KoCreatePathTool::createOptionWidgets;
     using KoCreatePathTool::endPathWithoutLastPoint;
     using KoCreatePathTool::endPath;
     using KoCreatePathTool::cancelPath;
     using KoCreatePathTool::removeLastPoint;
 
 protected:
     void paintOutline(QPainter *painter, const QPainterPath &path, qreal width);
 
 private:
     KisToolSelectMagnetic* const m_selectionTool;
 };
 
 typedef KisDelegatedTool<KisTool, __KisToolSelectMagneticLocalTool,
 DeselectShapesActivationPolicy> DelegatedSelectMagneticTool;
 
 struct KisDelegatedSelectMagneticWrapper : public DelegatedSelectMagneticTool {
     KisDelegatedSelectMagneticWrapper(KoCanvasBase *canvas,
                                   const QCursor &cursor,
                                   KisTool* delegateTool)
-        : DelegatedSelectMagneticTool(canvas, cursor, dynamic_cast<__KisToolSelectMagneticLocalTool*>(delegateTool))
+        : DelegatedSelectMagneticTool(canvas, cursor, (__KisToolSelectMagneticLocalTool*)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;
 
     bool hasUserInteractionRunning() const;
 };
 
 
 class KisToolSelectMagnetic : public KisToolSelectBase<KisDelegatedSelectMagneticWrapper>
 {
     Q_OBJECT
 public:
     KisToolSelectMagnetic(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 __KisToolSelectMagneticLocalTool;
     QList<QPointer<QWidget> > createOptionWidgets() override;
 };
 
 class KisToolSelectMagneticFactory : public KisSelectionToolFactoryBase
 {
 public:
     KisToolSelectMagneticFactory()
         : KisSelectionToolFactoryBase("KisToolSelectMagnetic") {
         setToolTip(i18n("Magnetic Selection Tool"));
         setSection(TOOL_TYPE_SELECTION);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
         setIconName(koIconNameCStr("tool_magnetic_selection"));
         setPriority(6);
     }
 
     ~KisToolSelectMagneticFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return new KisToolSelectMagnetic(canvas);
     }
 
 
 };
 
 
 
 #endif // KIS_TOOL_SELECT_MAGNETIC_H_