diff --git a/plugins/assistants/Assistants/EditAssistantsCommand.cpp b/plugins/assistants/Assistants/EditAssistantsCommand.cpp
index dd2f8c4542..69ef9eaa50 100644
--- a/plugins/assistants/Assistants/EditAssistantsCommand.cpp
+++ b/plugins/assistants/Assistants/EditAssistantsCommand.cpp
@@ -1,97 +1,98 @@
 /*
  *  Copyright (c) 2019 Tusooa Zhu <tusooa@vista.aero>
  *
  *  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 "EditAssistantsCommand.h"
 
 #include <QListIterator>
 
 #include <kis_canvas2.h>
 #include <KisView.h>
 #include <KisDocument.h>
 #include <KisViewManager.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_painting_assistants_decoration.h>
 
 EditAssistantsCommand::EditAssistantsCommand(QPointer<KisCanvas2> canvas, AssistantSPList origAssistants, AssistantSPList newAssistants, KUndo2Command *parent)
     : KUndo2Command(kundo2_i18n("Edit Assistants"), parent)
     , m_canvas(canvas)
     , m_origAssistants(origAssistants)
     , m_newAssistants(newAssistants)
     , m_index(-1)
     , m_firstRedo(true)
     , m_type(EDIT)
 {
 }
 
 EditAssistantsCommand::EditAssistantsCommand(QPointer<KisCanvas2> canvas, AssistantSPList origAssistants, AssistantSPList newAssistants, Type type, int index, KUndo2Command *parent)
     : KUndo2Command((type == ADD ? kundo2_i18n("Add Assistant") : kundo2_i18n("Remove Assistant")), parent)
     , m_canvas(canvas)
     , m_origAssistants(origAssistants)
     , m_newAssistants(newAssistants)
     , m_index(index)
     , m_firstRedo(true)
     , m_type(type)
 {
+    Q_UNUSED(m_index);
     KIS_ASSERT_RECOVER_RETURN(type != EDIT);
 }
 
 void EditAssistantsCommand::replaceWith(AssistantSPList assistants, Type type)
 {
     AssistantSPList curAssistants = m_canvas->paintingAssistantsDecoration()->assistants();
     if (type == EDIT) {
         KIS_ASSERT_RECOVER_RETURN(curAssistants.size() == assistants.size());
     } else if (type == ADD) {
         KIS_ASSERT_RECOVER_RETURN(curAssistants.size() == assistants.size() - 1);
     } else { // type == REMOVE
         KIS_ASSERT_RECOVER_RETURN(curAssistants.size() == assistants.size() + 1);
     }
 
     Q_FOREACH (KisPaintingAssistantSP assistant, curAssistants) {
         KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
         if (grid) {
             m_canvas->viewManager()->canvasResourceProvider()->removePerspectiveGrid(grid);
         }
     }
 
     m_canvas->paintingAssistantsDecoration()->setAssistants(assistants);
 
     Q_FOREACH (KisPaintingAssistantSP assistant, assistants) {
         assistant->uncache();
         KisAbstractPerspectiveGrid* grid = dynamic_cast<KisAbstractPerspectiveGrid*>(assistant.data());
         if (grid) {
             m_canvas->viewManager()->canvasResourceProvider()->addPerspectiveGrid(grid);
         }
     }
 
     m_canvas->updateCanvas();
 }
 
 void EditAssistantsCommand::undo()
 {
     replaceWith(m_origAssistants, Type(-m_type));
 }
 
 void EditAssistantsCommand::redo()
 {
     // this is a post-execution command
     if (m_firstRedo) {
         m_firstRedo = false;
         return;
     }
     replaceWith(m_newAssistants, m_type);
 }
diff --git a/plugins/assistants/Assistants/FisheyePointAssistant.cc b/plugins/assistants/Assistants/FisheyePointAssistant.cc
index dfc284b8a7..f97c8a59d9 100644
--- a/plugins/assistants/Assistants/FisheyePointAssistant.cc
+++ b/plugins/assistants/Assistants/FisheyePointAssistant.cc
@@ -1,239 +1,237 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "FisheyePointAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 #include <limits>
 
 FisheyePointAssistant::FisheyePointAssistant()
         : KisPaintingAssistant("fisheye-point", i18n("Fish Eye Point assistant"))
 {
 }
 
 FisheyePointAssistant::FisheyePointAssistant(const FisheyePointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , e(rhs.e)
     , extraE(rhs.extraE)
 {
 }
 
 KisPaintingAssistantSP FisheyePointAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new FisheyePointAssistant(*this, handleMap));
 }
 
 QPointF FisheyePointAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     const static QPointF nullPoint(std::numeric_limits<qreal>::quiet_NaN(), std::numeric_limits<qreal>::quiet_NaN());
     Q_ASSERT(isAssistantComplete());
     e.set(*handles()[0], *handles()[1], *handles()[2]);
 
     qreal
             dx = pt.x() - strokeBegin.x(),
             dy = pt.y() - strokeBegin.y();
         if (dx * dx + dy * dy < 4.0) {
             // allow some movement before snapping
             return strokeBegin;
         }
 
     //set the extrapolation ellipse.
     if (e.set(*handles()[0], *handles()[1], *handles()[2])){
         QLineF radius(*handles()[1], *handles()[0]);
         radius.setAngle(fmod(radius.angle()+180.0,360.0));
         QLineF radius2(*handles()[0], *handles()[1]);
         radius2.setAngle(fmod(radius2.angle()+180.0,360.0));
         if ( extraE.set(*handles()[0], *handles()[1],strokeBegin ) ) {
             return extraE.project(pt);
         } else if (extraE.set(radius.p1(), radius.p2(),strokeBegin)) {
             return extraE.project(pt);
         } else if (extraE.set(radius2.p1(), radius2.p2(),strokeBegin)){
             return extraE.project(pt);
         }   
     }
     
     return nullPoint;
     
 }
 
 QPointF FisheyePointAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void FisheyePointAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
-    QPointF delta(0,0);
+
     QPointF mousePos(0,0);
-    QPointF endPoint(0,0);//this is the final point that the line is being extended to, we seek it just outside the view port//
-    QPointF otherHandle(0,0);
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
     QTransform initialTransform = converter->documentToWidgetTransform();
     
     if (isSnappingActive() && previewVisible == true ) {
 
         if (isAssistantComplete()){
                 
             if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
                 if (extraE.set(*handles()[0], *handles()[1], initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(e.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 QLineF radius(*handles()[1], *handles()[0]);
                 radius.setAngle(fmod(radius.angle()+180.0,360.0));
                 if (extraE.set(radius.p1(), radius.p2(), initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(extraE.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 QLineF radius2(*handles()[0], *handles()[1]);
                 radius2.setAngle(fmod(radius2.angle()+180.0,360.0));
                 if (extraE.set(radius2.p1(), radius2.p2(), initialTransform.inverted().map(mousePos))){
                     gc.setTransform(initialTransform);
                     gc.setTransform(extraE.getInverse(), true);
                     QPainterPath path;
                     // Draw the ellipse
                     path.addEllipse(QPointF(0, 0), extraE.semiMajor(), extraE.semiMinor());
                     drawPreview(gc, path);
                 }
                 
             }
         }
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void FisheyePointAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false){
         return;
     }
     
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     if (handles().size() == 2) {
         // just draw the axis
         gc.setTransform(initialTransform);
         QPainterPath path;
         path.moveTo(*handles()[0]);
         path.lineTo(*handles()[1]);
         drawPath(gc, path, isSnappingActive());
         return;
     }
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         // valid ellipse
 
         gc.setTransform(initialTransform);
         gc.setTransform(e.getInverse(), true);
         QPainterPath path;
         //path.moveTo(QPointF(-e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), -e.semiMinor()));
         path.moveTo(QPointF(-e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(-e.semiMajor(), e.semiMinor()));
         //path.moveTo(QPointF(-e.semiMajor(), e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), e.semiMinor()));
         path.moveTo(QPointF(e.semiMajor(), -e.semiMinor())); path.lineTo(QPointF(e.semiMajor(), e.semiMinor()));
         path.moveTo(QPointF(-(e.semiMajor()*3), -e.semiMinor())); path.lineTo(QPointF(-(e.semiMajor()*3), e.semiMinor()));
         path.moveTo(QPointF((e.semiMajor()*3), -e.semiMinor())); path.lineTo(QPointF((e.semiMajor()*3), e.semiMinor()));
         path.moveTo(QPointF(-e.semiMajor(), 0)); path.lineTo(QPointF(e.semiMajor(), 0));
         //path.moveTo(QPointF(0, -e.semiMinor())); path.lineTo(QPointF(0, e.semiMinor()));
         // Draw the ellipse
         path.addEllipse(QPointF(0, 0), e.semiMajor(), e.semiMinor());
         drawPath(gc, path, isSnappingActive());
     }
     
 }
 
 QRect FisheyePointAssistant::boundingRect() const
 {
     if (!isAssistantComplete()) {
         return KisPaintingAssistant::boundingRect();
     }
 
     if (e.set(*handles()[0], *handles()[1], *handles()[2])) {
         return e.boundingRect().adjusted(-(e.semiMajor()*2), -2, (e.semiMajor()*2), 2).toAlignedRect();
     } else {
         return QRect();
     }
 }
 
 QPointF FisheyePointAssistant::buttonPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool FisheyePointAssistant::isAssistantComplete() const
 {
     return handles().size() >= 3;
 }
 
 
 FisheyePointAssistantFactory::FisheyePointAssistantFactory()
 {
 }
 
 FisheyePointAssistantFactory::~FisheyePointAssistantFactory()
 {
 }
 
 QString FisheyePointAssistantFactory::id() const
 {
     return "fisheye-point";
 }
 
 QString FisheyePointAssistantFactory::name() const
 {
     return i18n("Fish Eye Point");
 }
 
 KisPaintingAssistant* FisheyePointAssistantFactory::createPaintingAssistant() const
 {
     return new FisheyePointAssistant;
 }
diff --git a/plugins/assistants/Assistants/InfiniteRulerAssistant.cc b/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
index 65ed5f3a45..4ce58eedff 100644
--- a/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
+++ b/plugins/assistants/Assistants/InfiniteRulerAssistant.cc
@@ -1,172 +1,170 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "InfiniteRulerAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 InfiniteRulerAssistant::InfiniteRulerAssistant()
         : KisPaintingAssistant("infinite ruler", i18n("Infinite Ruler assistant"))
 {
 }
 
 InfiniteRulerAssistant::InfiniteRulerAssistant(const InfiniteRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 KisPaintingAssistantSP InfiniteRulerAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new InfiniteRulerAssistant(*this, handleMap));
 }
 
 QPointF InfiniteRulerAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     Q_ASSERT(isAssistantComplete());
     //code nicked from the perspective ruler.
     qreal
             dx = pt.x() - strokeBegin.x(),
             dy = pt.y() - strokeBegin.y();
         if (dx * dx + dy * dy < 4.0) {
             // allow some movement before snapping
             return strokeBegin;
         }
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], *handles()[1]);
     
     
         dx = snapLine.dx();
         dy = snapLine.dy();
     const qreal
         dx2 = dx * dx,
         dy2 = dy * dy,
         invsqrlen = 1.0 / (dx2 + dy2);
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
     r *= invsqrlen;
     return r;
     //return pt;
 }
 
 QPointF InfiniteRulerAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void InfiniteRulerAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
-    QPointF delta(0,0);//this is the difference between the window and the widget//
     QPointF mousePos(0,0);
-    QPointF endPoint(0,0);//this is the final point that the line is being extended to, we seek it just outside the view port//
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
 
 
     
     if (isAssistantComplete() && isSnappingActive() && previewVisible == true) {
         //don't draw if invalid.
         QTransform initialTransform = converter->documentToWidgetTransform();
         QLineF snapLine= QLineF(initialTransform.map(*handles()[0]), initialTransform.map(*handles()[1]));
         QRect viewport= gc.viewport();
         KisAlgebra2D::intersectLineRect(snapLine, viewport);
         QPainterPath path;
         path.moveTo(snapLine.p1());
         path.lineTo(snapLine.p2());
         drawPreview(gc, path);//and we draw the preview.
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void InfiniteRulerAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || !isAssistantComplete()){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     // Draw the line
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     gc.setTransform(initialTransform);
     QPainterPath path;
     path.moveTo(p1);
     path.lineTo(p2);
     drawPath(gc, path, isSnappingActive());
     
 }
 
 QPointF InfiniteRulerAssistant::buttonPosition() const
 {
     return (*handles()[0]);
 }
 
 bool InfiniteRulerAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 InfiniteRulerAssistantFactory::InfiniteRulerAssistantFactory()
 {
 }
 
 InfiniteRulerAssistantFactory::~InfiniteRulerAssistantFactory()
 {
 }
 
 QString InfiniteRulerAssistantFactory::id() const
 {
     return "infinite ruler";
 }
 
 QString InfiniteRulerAssistantFactory::name() const
 {
     return i18n("Infinite Ruler");
 }
 
 KisPaintingAssistant* InfiniteRulerAssistantFactory::createPaintingAssistant() const
 {
     return new InfiniteRulerAssistant;
 }
diff --git a/plugins/assistants/Assistants/ParallelRulerAssistant.cc b/plugins/assistants/Assistants/ParallelRulerAssistant.cc
index 2afd501cce..766da9b21e 100644
--- a/plugins/assistants/Assistants/ParallelRulerAssistant.cc
+++ b/plugins/assistants/Assistants/ParallelRulerAssistant.cc
@@ -1,179 +1,177 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "ParallelRulerAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 
 #include <math.h>
 
 ParallelRulerAssistant::ParallelRulerAssistant()
     : KisPaintingAssistant("parallel ruler", i18n("Parallel Ruler assistant"))
 {
 }
 
 KisPaintingAssistantSP ParallelRulerAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new ParallelRulerAssistant(*this, handleMap));
 }
 
 ParallelRulerAssistant::ParallelRulerAssistant(const ParallelRulerAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
 {
 }
 
 QPointF ParallelRulerAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     Q_ASSERT(isAssistantComplete());
 
     //code nicked from the perspective ruler.
     qreal dx = pt.x() - strokeBegin.x();
     qreal dy = pt.y() - strokeBegin.y();
 
     if (dx * dx + dy * dy < 4.0) {
         return strokeBegin; // allow some movement before snapping
     }
 
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], *handles()[1]);
     QPointF translation = (*handles()[0]-strokeBegin)*-1.0;
     snapLine = snapLine.translated(translation);
         
     dx = snapLine.dx();
     dy = snapLine.dy();
 
     const qreal
             dx2 = dx * dx,
             dy2 = dy * dy,
             invsqrlen = 1.0 / (dx2 + dy2);
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
     r *= invsqrlen;
     return r;
     //return pt;
 }
 
 QPointF ParallelRulerAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void ParallelRulerAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     gc.save();
     gc.resetTransform();
-    QPointF delta(0,0);//this is the difference between the vanishing point and the mouse-position//
     QPointF mousePos(0,0);
-    QPointF endPoint(0,0);//this is the final point that the line is being extended to, we seek it just outside the view port//
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
     if (isAssistantComplete() && isSnappingActive() && previewVisible==true) {
         //don't draw if invalid.
         QTransform initialTransform = converter->documentToWidgetTransform();
         QLineF snapLine= QLineF(initialTransform.map(*handles()[0]), initialTransform.map(*handles()[1]));
         QPointF translation = (initialTransform.map(*handles()[0])-mousePos)*-1.0;
         snapLine= snapLine.translated(translation);
 
         QRect viewport= gc.viewport();
         KisAlgebra2D::intersectLineRect(snapLine, viewport);
         
         
         QPainterPath path;
         path.moveTo(snapLine.p1());
         path.lineTo(snapLine.p2());
         
         drawPreview(gc, path);//and we draw the preview.
     }
     gc.restore();
     
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 
 }
 
 void ParallelRulerAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (assistantVisible == false || !isAssistantComplete()){
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
 
     // Draw the line
     QPointF p1 = *handles()[0];
     QPointF p2 = *handles()[1];
 
     gc.setTransform(initialTransform);
     QPainterPath path;
     path.moveTo(p1);
     path.lineTo(p2);
     drawPath(gc, path, isSnappingActive());
     
 }
 
 QPointF ParallelRulerAssistant::buttonPosition() const
 {
     return (*handles()[0] + *handles()[1]) * 0.5;
 }
 
 bool ParallelRulerAssistant::isAssistantComplete() const
 {
     return handles().size() >= 2;
 }
 
 ParallelRulerAssistantFactory::ParallelRulerAssistantFactory()
 {
 }
 
 ParallelRulerAssistantFactory::~ParallelRulerAssistantFactory()
 {
 }
 
 QString ParallelRulerAssistantFactory::id() const
 {
     return "parallel ruler";
 }
 
 QString ParallelRulerAssistantFactory::name() const
 {
     return i18n("Parallel Ruler");
 }
 
 KisPaintingAssistant* ParallelRulerAssistantFactory::createPaintingAssistant() const
 {
     return new ParallelRulerAssistant;
 }
diff --git a/plugins/assistants/Assistants/VanishingPointAssistant.cc b/plugins/assistants/Assistants/VanishingPointAssistant.cc
index be7006ac60..31f91b9637 100644
--- a/plugins/assistants/Assistants/VanishingPointAssistant.cc
+++ b/plugins/assistants/Assistants/VanishingPointAssistant.cc
@@ -1,319 +1,317 @@
 /*
  * Copyright (c) 2008 Cyrille Berger <cberger@cberger.net>
  * Copyright (c) 2010 Geoffry Song <goffrie@gmail.com>
  * Copyright (c) 2014 Wolthera van Hövell tot Westerflier <griffinvalley@gmail.com>
  * Copyright (c) 2017 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This library is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
  *  the Free Software Foundation; version 2.1 of the License.
  *
  *  This library 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 Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser 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 "VanishingPointAssistant.h"
 
 #include "kis_debug.h"
 #include <klocalizedstring.h>
 
 #include <QPainter>
 #include <QLinearGradient>
 #include <QTransform>
 
 #include <kis_canvas2.h>
 #include <kis_coordinates_converter.h>
 #include <kis_algebra_2d.h>
 #include <kis_dom_utils.h>
 #include <math.h>
 
 VanishingPointAssistant::VanishingPointAssistant()
     : KisPaintingAssistant("vanishing point", i18n("Vanishing Point assistant"))
 {
 }
 
 VanishingPointAssistant::VanishingPointAssistant(const VanishingPointAssistant &rhs, QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap)
     : KisPaintingAssistant(rhs, handleMap)
     , m_canvas(rhs.m_canvas)
     , m_referenceLineDensity(rhs.m_referenceLineDensity)
 {
 }
 
 KisPaintingAssistantSP VanishingPointAssistant::clone(QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> &handleMap) const
 {
     return KisPaintingAssistantSP(new VanishingPointAssistant(*this, handleMap));
 }
 
 QPointF VanishingPointAssistant::project(const QPointF& pt, const QPointF& strokeBegin)
 {
     //Q_ASSERT(handles().size() == 1 || handles().size() == 5);
     //code nicked from the perspective ruler.
     qreal dx = pt.x() - strokeBegin.x();
     qreal dy = pt.y() - strokeBegin.y();
 
     if (dx * dx + dy * dy < 4.0) {
         // allow some movement before snapping
         return strokeBegin;
     }
 
     //dbgKrita<<strokeBegin<< ", " <<*handles()[0];
     QLineF snapLine = QLineF(*handles()[0], strokeBegin);
     
     
     dx = snapLine.dx();
     dy = snapLine.dy();
 
     const qreal dx2 = dx * dx;
     const qreal dy2 = dy * dy;
     const qreal invsqrlen = 1.0 / (dx2 + dy2);
 
     QPointF r(dx2 * pt.x() + dy2 * snapLine.x1() + dx * dy * (pt.y() - snapLine.y1()),
               dx2 * snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - snapLine.x1()));
 
     r *= invsqrlen;
     return r;
 }
 
 QPointF VanishingPointAssistant::adjustPosition(const QPointF& pt, const QPointF& strokeBegin)
 {
     return project(pt, strokeBegin);
 }
 
 void VanishingPointAssistant::drawAssistant(QPainter& gc, const QRectF& updateRect, const KisCoordinatesConverter* converter, bool cached, KisCanvas2* canvas, bool assistantVisible, bool previewVisible)
 {
     // HACK ALERT: side handles aren't saved
     // we need to just add a default position for now if we are loading a vanishing point
     // we will need to look at how we load/save assistants in general to remedy this
     if (sideHandles().isEmpty()) {
         QPointF vpPoint = *handles()[0]; // main vanishing point
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-70,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(-140,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(70,0)), HandleType::SIDE);
         addHandle(new KisPaintingAssistantHandle(vpPoint + QPointF(140,0)), HandleType::SIDE);
     }
 
     gc.save();
     gc.resetTransform();
-    QPointF delta(0,0);
     QPointF mousePos(0,0);
-    QPointF endPoint(0,0);//this is the final point that the line is being extended to, we seek it just outside the view port//
     
     if (canvas){
         //simplest, cheapest way to get the mouse-position//
         mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
         m_canvas = canvas;
     }
     else {
         //...of course, you need to have access to a canvas-widget for that.//
         mousePos = QCursor::pos();//this'll give an offset//
         dbgFile<<"canvas does not exist in ruler, you may have passed arguments incorrectly:"<<canvas;
     }
     
 
 
      // draw controls when we are not editing
      if (canvas->paintingAssistantsDecoration()->isEditingAssistants() == false && isAssistantComplete()) {
 
          if (isSnappingActive() && previewVisible == true) {
              //don't draw if invalid.
              QTransform initialTransform = converter->documentToWidgetTransform();
              QPointF startPoint = initialTransform.map(*handles()[0]);
 
              QLineF snapLine= QLineF(startPoint, mousePos);
              QRect viewport= gc.viewport();
 
              KisAlgebra2D::intersectLineRect(snapLine, viewport);
 
              QRect bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
 
              QPainterPath path;
 
              if (bounds.contains(startPoint.toPoint())){
                  path.moveTo(startPoint);
                  path.lineTo(snapLine.p1());
              }
              else
              {
                  path.moveTo(snapLine.p1());
                  path.lineTo(snapLine.p2());
              }
 
              drawPreview(gc, path);//and we draw the preview.
          }
      }
 
 
 
 
     // editor specific controls display
     if (canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
 
         // draws a circle around the vanishing point node while editing
         QTransform initialTransform = converter->documentToWidgetTransform();
         QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
         QPointF p1 = initialTransform.map(*sideHandles()[0]);
         QPointF p2 = initialTransform.map(*sideHandles()[1]);
         QPointF p3 = initialTransform.map(*sideHandles()[2]);
         QPointF p4 = initialTransform.map(*sideHandles()[3]);
 
 
         QRectF ellipse = QRectF(QPointF(p0.x() -15, p0.y() -15), QSizeF(30, 30));
 
         QPainterPath pathCenter;
         pathCenter.addEllipse(ellipse);
         drawPath(gc, pathCenter, isSnappingActive());
 
         QColor paintingColor = effectiveAssistantColor();
 
 
         // draw the lines connecting the different nodes
         QPen penStyle(paintingColor, 2.0, Qt::SolidLine);
 
         if (!isSnappingActive()) {
             QColor snappingColor = paintingColor;
             snappingColor.setAlpha(snappingColor.alpha() * 0.2);
 
             penStyle.setColor(snappingColor);
         }
 
         gc.save();
         gc.setPen(penStyle);
         gc.drawLine(p0, p1);
         gc.drawLine(p0, p3);
         gc.drawLine(p1, p2);
         gc.drawLine(p3, p4);
         gc.restore();
     }
 
 
     // draw references guide for vanishing points at specified density
     // this is shown as part of the preview, so don't show if preview is off
     if( canvas->paintingAssistantsDecoration()->outlineVisibility() && this->isSnappingActive() ) {
 
         // cycle through degrees from 0 to 180. We are doing an infinite line, so we don't need to go 360
         QTransform initialTransform = converter->documentToWidgetTransform();
         QPointF p0 = initialTransform.map(*handles()[0]); // main vanishing point
 
         for (int currentAngle=0; currentAngle <= 180; currentAngle = currentAngle + m_referenceLineDensity ) {
 
            // determine the correct angle based on the iteration
            float xPos = cos(currentAngle * M_PI / 180);
            float yPos = sin(currentAngle * M_PI / 180);
            QPointF unitAngle;
            unitAngle.setX(p0.x() + xPos);
            unitAngle.setY(p0.y() + yPos);
 
            // find point
            QLineF snapLine= QLineF(p0, unitAngle);
            QRect viewport= gc.viewport();
            KisAlgebra2D::intersectLineRect(snapLine, viewport);
 
            // make a line from VP center to edge of canvas with that angle
            QPainterPath path;
            path.moveTo(snapLine.p1());
            path.lineTo(snapLine.p2());
            drawPreview(gc, path);//and we draw the preview.
         }
     }
 
 
     gc.restore();
 
     KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached, canvas, assistantVisible, previewVisible);
 }
 
 void VanishingPointAssistant::drawCache(QPainter& gc, const KisCoordinatesConverter *converter, bool assistantVisible)
 {
     if (!m_canvas || !isAssistantComplete()) {
         return;
     }
 
     if (assistantVisible == false ||   m_canvas->paintingAssistantsDecoration()->isEditingAssistants()) {
         return;
     }
 
     QTransform initialTransform = converter->documentToWidgetTransform();
     QPointF p0 = initialTransform.map(*handles()[0]);
 
     // draws an "X"
     QPainterPath path;
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() - 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() + 10.0));
 
     path.moveTo(QPointF(p0.x() - 10.0, p0.y() + 10.0));
     path.lineTo(QPointF(p0.x() + 10.0, p0.y() - 10.0));
 
 
     drawPath(gc, path, isSnappingActive());
 }
 
 QPointF VanishingPointAssistant::buttonPosition() const
 {
     return (*handles()[0]);
 }
 
 void VanishingPointAssistant::setReferenceLineDensity(float value)
 {
     // cannot have less than 1 degree value
     if (value < 1.0) {
         value = 1.0;
     }
 
     m_referenceLineDensity = value;
 }
 
 float VanishingPointAssistant::referenceLineDensity()
 {
     return m_referenceLineDensity;
 }
 
 bool VanishingPointAssistant::isAssistantComplete() const
 {
     return handles().size() > 0; // only need one point to be ready
 }
 
 void VanishingPointAssistant::saveCustomXml(QXmlStreamWriter* xml)
 {
     xml->writeStartElement("angleDensity");
     xml->writeAttribute("value", KisDomUtils::toString( this->referenceLineDensity()));
     xml->writeEndElement();
 }
 
 bool VanishingPointAssistant::loadCustomXml(QXmlStreamReader* xml)
 {
     if (xml && xml->name() == "angleDensity") {
          this->setReferenceLineDensity((float)KisDomUtils::toDouble(xml->attributes().value("value").toString()));
     }
 
     return true;
 }
 
 
 VanishingPointAssistantFactory::VanishingPointAssistantFactory()
 {
 }
 
 VanishingPointAssistantFactory::~VanishingPointAssistantFactory()
 {
 }
 
 QString VanishingPointAssistantFactory::id() const
 {
     return "vanishing point";
 }
 
 QString VanishingPointAssistantFactory::name() const
 {
     return i18n("Vanishing Point");
 }
 
 KisPaintingAssistant* VanishingPointAssistantFactory::createPaintingAssistant() const
 {
     return new VanishingPointAssistant;
 }