diff --git a/libs/libkis/Scratchpad.cpp b/libs/libkis/Scratchpad.cpp
index 46abbe56f6..8e1b477803 100644
--- a/libs/libkis/Scratchpad.cpp
+++ b/libs/libkis/Scratchpad.cpp
@@ -1,50 +1,58 @@
 /*
  *  Copyright (c) 2020 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This program 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; 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 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 "Scratchpad.h"
 #include <KoResource.h>
 #include <kis_config.h>
 #include "kis_scratch_pad.h"
 #include "Resource.h"
 #include "View.h"
 #include "Canvas.h"
 #include <KoCanvasBase.h>
 #include <kis_canvas2.h>
 
 #include <QColor>
 
-struct Scratchpad::Private {
-    Private() {}
-   // View *view = 0;
-};
-
-
 Scratchpad::Scratchpad(View *view, const QString & defaultColor, QWidget *parent)
     : KisScratchPad(parent)
 {    
 
     // todo hook this up later to override
     const QColor backgroundColor = QColor(Qt::white);
 
     KisScratchPad::setupScratchPad(view->view()->resourceProvider(), backgroundColor);
     KisScratchPad::setMinimumSize(50, 50);
 }
 
 Scratchpad::~Scratchpad()
 {
-    delete d;
+}
+
+void Scratchpad::setModeManually(bool value)
+{
+    KisScratchPad::setModeManually(value);
+}
+
+void Scratchpad::setMode(QString modeType)
+{
+    KisScratchPad::setModeType(modeType);
+}
+
+void Scratchpad::clear()
+{
+    KisScratchPad::fillDefault();
 }
diff --git a/libs/libkis/Scratchpad.h b/libs/libkis/Scratchpad.h
index b9ce5c84de..8b95e6f1bc 100644
--- a/libs/libkis/Scratchpad.h
+++ b/libs/libkis/Scratchpad.h
@@ -1,52 +1,65 @@
 /*
  *  Copyright (c) 2020 Scott Petrovic <scottpetrovic@gmail.com>
  *
  *  This program 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; 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 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.
  */
 #ifndef LIBKIS_SCRATCHPAD_H
 #define LIBKIS_SCRATCHPAD_H
 
 #include <QObject>
 #include <QColor>
 #include <kis_types.h>
 #include "kritalibkis_export.h"
 #include "libkis.h"
 #include "kis_scratch_pad.h"
 #include "View.h"
 
 class KoCanvasBase;
 class Canvas; // This comes from Python. This would be maybe better
 class KisView;
 
 /**
  * @brief The Scratchpad class
  * A scratchpad is a type of blank canvas area that can be painted on 
  * with the normal painting devices
  *
  */
 class KRITALIBKIS_EXPORT Scratchpad: public KisScratchPad
 {
     Q_OBJECT
 public:
     Scratchpad(View *view, const QString & defaultColor, QWidget *parent = 0);
     ~Scratchpad();
 
-private:
-    struct Private;
-    Private *d;
+
+public Q_SLOTS:
+
+    /**
+     * clears out scratchpad with whatever default color was set during setup
+     */
+    void clear();
+
+    /** Switches between a GUI controlling the current mode and when mouse clicks control mode
+     * Setting to true allows GUI to control the mode with explicity setting mode
+     */
+    void setModeManually(bool value);
+
+
+    /// Manually set what mode scratchpad is in. Ignored if "setModeManually is set to false
+    void setMode(QString modeName);
 };
 
 #endif // LIBKIS_SCRATCHPAD_H
 
diff --git a/libs/ui/widgets/kis_scratch_pad.cpp b/libs/ui/widgets/kis_scratch_pad.cpp
index 7d4f622733..c0f90c3ca2 100644
--- a/libs/ui/widgets/kis_scratch_pad.cpp
+++ b/libs/ui/widgets/kis_scratch_pad.cpp
@@ -1,536 +1,608 @@
 /* This file is part of the KDE project
  * Copyright 2010 (C) Boudewijn Rempt <boud@valdyas.org>
  * Copyright 2011 (C) Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #include "kis_scratch_pad.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 
 #include <KoColorSpace.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoPointerEvent.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kis_cursor.h>
 #include <kis_tool_utils.h>
 #include <kis_paint_layer.h>
 #include <kis_paint_device.h>
 #include <kis_gradient_painter.h>
 #include <kis_default_bounds.h>
 #include <kis_canvas_resource_provider.h>
 
 #include "kis_config.h"
 #include "kis_image.h"
 #include "kis_undo_stores.h"
 #include "kis_update_scheduler.h"
 #include "kis_post_execution_undo_adapter.h"
 #include "kis_scratch_pad_event_filter.h"
 #include "kis_painting_information_builder.h"
 #include "kis_tool_freehand_helper.h"
 #include "kis_image_patch.h"
 #include "kis_canvas_widget_base.h"
 #include "kis_layer_projection_plane.h"
 #include "kis_node_graph_listener.h"
 #include "kis_transaction.h"
 
 class KisScratchPadNodeListener : public KisNodeGraphListener
 {
 public:
     KisScratchPadNodeListener(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     void requestProjectionUpdate(KisNode *node, const QVector<QRect> &rects, bool resetAnimationCache) override {
         KisNodeGraphListener::requestProjectionUpdate(node, rects, resetAnimationCache);
 
         QMutexLocker locker(&m_lock);
 
         Q_FOREACH (const QRect &rc, rects) {
             m_scratchPad->imageUpdated(rc);
         }
     }
 
 private:
     KisScratchPad *m_scratchPad;
     QMutex m_lock;
 };
 
 
 class KisScratchPadDefaultBounds : public KisDefaultBounds
 {
 public:
 
     KisScratchPadDefaultBounds(KisScratchPad *scratchPad)
         : m_scratchPad(scratchPad)
     {
     }
 
     ~KisScratchPadDefaultBounds() override {}
 
     QRect bounds() const override {
         return m_scratchPad->imageBounds();
     }
 
     void * sourceCookie() const override {
         return m_scratchPad;
     }
 
 private:
     Q_DISABLE_COPY(KisScratchPadDefaultBounds)
 
     KisScratchPad *m_scratchPad;
 };
 
 
 KisScratchPad::KisScratchPad(QWidget *parent)
     : QWidget(parent)
     , m_toolMode(HOVERING)
     , m_paintLayer(0)
     , m_displayProfile(0)
     , m_resourceProvider(0)
 {
     setAutoFillBackground(false);
     setMouseTracking(true);
 
     m_cursor = KisCursor::load("tool_freehand_cursor.png", 5, 5);
+    m_colorPickerCursor = KisCursor::load("color-picker_image_foreground.xpm", 5, 5);
     setCursor(m_cursor);
 
+
     KisConfig cfg(true);
     QImage checkImage = KisCanvasWidgetBase::createCheckersImage(cfg.checkSize());
     m_checkBrush = QBrush(checkImage);
 
 
     // We are not supposed to use updates here,
     // so just set the listener to null
     m_updateScheduler = new KisUpdateScheduler(0);
     m_undoStore = new KisSurrogateUndoStore();
     m_undoAdapter = new KisPostExecutionUndoAdapter(m_undoStore, m_updateScheduler);
     m_nodeListener = new KisScratchPadNodeListener(this);
 
     connect(this, SIGNAL(sigUpdateCanvas(QRect)), SLOT(slotUpdateCanvas(QRect)), Qt::QueuedConnection);
 
     // filter will be deleted by the QObject hierarchy
     m_eventFilter = new KisScratchPadEventFilter(this);
 
     m_infoBuilder = new KisPaintingInformationBuilder();
 
     m_scaleBorderWidth = 1;
 }
 
 KisScratchPad::~KisScratchPad()
 {
     delete m_infoBuilder;
 
     delete m_undoAdapter;
     delete m_undoStore;
     delete m_updateScheduler;
     delete m_nodeListener;
 }
 
 KisScratchPad::Mode KisScratchPad::modeFromButton(Qt::MouseButton button) const
 {
     return
         button == Qt::NoButton ? HOVERING :
         button == Qt::MidButton ? PANNING :
         button == Qt::RightButton ? PICKING :
         PAINTING;
 }
 
 void KisScratchPad::pointerPress(KoPointerEvent *event)
 {
-    if (m_toolMode != HOVERING) return;
+    if (isModeManuallySet == false) {
 
-    m_toolMode = modeFromButton(event->button());
+        if (m_toolMode != HOVERING) return;
+
+        m_toolMode = modeFromButton(event->button());
 
-    if (m_toolMode == PAINTING) {
-        beginStroke(event);
-        event->accept();
     }
-    else if (m_toolMode == PANNING) {
-        beginPan(event);
-        event->accept();
+
+    // see if we are pressing down with a button
+    if (event->button() == Qt::LeftButton ||
+        event->button() == Qt::MidButton ||
+        event->button() == Qt::RightButton) {
+        isMouseDown = true;
+    } else {
+        isMouseDown = false;
     }
-    else if (m_toolMode == PICKING) {
-        pick(event);
-        event->accept();
+
+    // if mouse is down, we are doing one of three things
+    if(isMouseDown) {
+        if (m_toolMode == PAINTING) {
+            beginStroke(event);
+            event->accept();
+        }
+        else if (m_toolMode == PANNING) {
+            beginPan(event);
+            event->accept();
+        }
+        else if (m_toolMode == PICKING) {
+            pick(event);
+            event->accept();
+        }
     }
+
 }
 
 void KisScratchPad::pointerRelease(KoPointerEvent *event)
 {
-    if (modeFromButton(event->button()) != m_toolMode) return;
+    isMouseDown = false;
+
+    if (isModeManuallySet == false) {
+        if (modeFromButton(event->button()) != m_toolMode) return;
+
+        if (m_toolMode == PAINTING) {
+            endStroke(event);
+            m_toolMode = HOVERING;
+            event->accept();
+        }
+        else if (m_toolMode == PANNING) {
+            endPan(event);
+            m_toolMode = HOVERING;
+            event->accept();
+        }
+        else if (m_toolMode == PICKING) {
+            event->accept();
+            m_toolMode = HOVERING;
+        }
+
+    } else {
+        if (m_toolMode == PAINTING) {
+            endStroke(event);
+        }
+        else if (m_toolMode == PANNING) {
+            endPan(event);
+        }
 
-    if (m_toolMode == PAINTING) {
-        endStroke(event);
-        m_toolMode = HOVERING;
-        event->accept();
-    }
-    else if (m_toolMode == PANNING) {
-        endPan(event);
-        m_toolMode = HOVERING;
-        event->accept();
-    }
-    else if (m_toolMode == PICKING) {
         event->accept();
-        m_toolMode = HOVERING;
     }
+
+
 }
 
 void KisScratchPad::pointerMove(KoPointerEvent *event)
 {
-    m_helper->cursorMoved(documentToWidget().map(event->point));
-    if (m_toolMode == PAINTING) {
-        doStroke(event);
-        event->accept();
-    }
-    else if (m_toolMode == PANNING) {
-        doPan(event);
-        event->accept();
+    if(event && event->point.isNull() == false) {
+        m_helper->cursorMoved(documentToWidget().map(event->point));
     }
-    else if (m_toolMode == PICKING) {
-        pick(event);
-        event->accept();
+
+
+    if (isMouseDown) {
+        if (m_toolMode == PAINTING) {
+            doStroke(event);
+            event->accept();
+        }
+        else if (m_toolMode == PANNING) {
+            doPan(event);
+            event->accept();
+        }
+        else if (m_toolMode == PICKING) {
+            pick(event);
+            event->accept();
+        }
     }
 }
 
 void KisScratchPad::beginStroke(KoPointerEvent *event)
 {
+
     m_helper->initPaint(event,
                         documentToWidget().map(event->point),
                         0,
                         0,
                         m_updateScheduler,
                         m_paintLayer,
                         m_paintLayer->paintDevice()->defaultBounds());
+
+
 }
 
 void KisScratchPad::doStroke(KoPointerEvent *event)
 {
     m_helper->paintEvent(event);
 }
 
 void KisScratchPad::endStroke(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     m_helper->endPaint();
 }
 
 void KisScratchPad::beginPan(KoPointerEvent *event)
 {
     setCursor(QCursor(Qt::ClosedHandCursor));
     m_panDocPoint = event->point;
 }
 
 void KisScratchPad::doPan(KoPointerEvent *event)
 {
     QPointF docOffset = event->point - m_panDocPoint;
 
     m_translateTransform.translate(-docOffset.x(), -docOffset.y());
     updateTransformations();
     update();
 }
 
 void KisScratchPad::endPan(KoPointerEvent *event)
 {
     Q_UNUSED(event);
-    setCursor(m_cursor);
+
+    // the normal brush editor scratchpad reverts back to paint mode when done
+    if(isModeManuallySet) {
+        setCursor(QCursor(Qt::OpenHandCursor));
+    } else {
+        setCursor(m_cursor);
+    }
+
 }
 
 void KisScratchPad::pick(KoPointerEvent *event)
 {
     KoColor color;
     if (KisToolUtils::pickColor(color, m_paintLayer->projection(), event->point.toPoint())) {
         emit colorSelected(color);
     }
 }
 
 void KisScratchPad::setOnScreenResolution(qreal scaleX, qreal scaleY)
 {
     m_scaleBorderWidth = BORDER_SIZE(qMax(scaleX, scaleY));
 
     m_scaleTransform = QTransform::fromScale(scaleX, scaleY);
     updateTransformations();
     update();
 }
 
 QTransform KisScratchPad::documentToWidget() const
 {
     return m_translateTransform.inverted() * m_scaleTransform;
 }
 
 QTransform KisScratchPad::widgetToDocument() const
 {
     return m_scaleTransform.inverted() * m_translateTransform;
 }
 
 void KisScratchPad::updateTransformations()
 {
     m_eventFilter->setWidgetToDocumentTransform(widgetToDocument());
 }
 
 QRect KisScratchPad::imageBounds() const
 {
     return widgetToDocument().mapRect(rect());
 }
 
 void KisScratchPad::imageUpdated(const QRect &rect)
 {
     emit sigUpdateCanvas(documentToWidget().mapRect(QRectF(rect)).toAlignedRect());
 }
 
 void KisScratchPad::slotUpdateCanvas(const QRect &rect)
 {
     update(rect);
 }
 
 void KisScratchPad::paintEvent ( QPaintEvent * event ) {
     if(!m_paintLayer) return;
 
     QRectF imageRect = widgetToDocument().mapRect(QRectF(event->rect()));
 
     QRect alignedImageRect =
         imageRect.adjusted(-m_scaleBorderWidth, -m_scaleBorderWidth,
                            m_scaleBorderWidth, m_scaleBorderWidth).toAlignedRect();
 
     QPointF offset = alignedImageRect.topLeft();
 
     m_paintLayer->projectionPlane()->recalculate(alignedImageRect, m_paintLayer);
     KisPaintDeviceSP projection = m_paintLayer->projection();
 
     QImage image = projection->convertToQImage(m_displayProfile,
                                                alignedImageRect.x(),
                                                alignedImageRect.y(),
                                                alignedImageRect.width(),
                                                alignedImageRect.height(),
                                                KoColorConversionTransformation::internalRenderingIntent(),
                                                KoColorConversionTransformation::internalConversionFlags());
 
     QPainter gc(this);
     gc.fillRect(event->rect(), m_checkBrush);
 
     gc.setRenderHints(QPainter::SmoothPixmapTransform);
     gc.drawImage(QRectF(event->rect()), image, imageRect.translated(-offset));
 
     QBrush brush(Qt::lightGray);
     QPen pen(brush, 1, Qt::DotLine);
     gc.setPen(pen);
     if (m_cutoutOverlay.isValid()) {
         gc.drawRect(m_cutoutOverlay);
     }
 
     if(!isEnabled()) {
         QColor color(Qt::lightGray);
         color.setAlphaF(0.5);
         QBrush disabledBrush(color);
         gc.fillRect(event->rect(), disabledBrush);
     }
     gc.end();
 }
 
 void KisScratchPad::setupScratchPad(KisCanvasResourceProvider* resourceProvider,
                                     const QColor &defaultColor)
 {
     m_resourceProvider = resourceProvider;
     KisConfig cfg(true);
     setDisplayProfile(cfg.displayProfile(QApplication::desktop()->screenNumber(this)));
     connect(m_resourceProvider, SIGNAL(sigDisplayProfileChanged(const KoColorProfile*)),
             SLOT(setDisplayProfile(const KoColorProfile*)));
 
     connect(m_resourceProvider, SIGNAL(sigOnScreenResolutionChanged(qreal,qreal)),
             SLOT(setOnScreenResolution(qreal,qreal)));
     connect(this, SIGNAL(colorSelected(KoColor)),
             m_resourceProvider, SLOT(slotSetFGColor(KoColor)));
 
     m_helper.reset(new KisToolFreehandHelper(m_infoBuilder, m_resourceProvider->resourceManager()));
 
     m_defaultColor = KoColor(defaultColor, KoColorSpaceRegistry::instance()->rgb8());
 
     KisPaintDeviceSP paintDevice =
         new KisPaintDevice(m_defaultColor.colorSpace(), "scratchpad");
 
     m_paintLayer = new KisPaintLayer(0, "ScratchPad", OPACITY_OPAQUE_U8, paintDevice);
     m_paintLayer->setGraphListener(m_nodeListener);
     m_paintLayer->paintDevice()->setDefaultBounds(new KisScratchPadDefaultBounds(this));
 
     fillDefault();
 }
 
 void KisScratchPad::setCutoutOverlayRect(const QRect& rc)
 {
     m_cutoutOverlay = rc;
 }
 
+void KisScratchPad::setModeManually(bool value)
+{
+    isModeManuallySet = value;
+}
+
+void KisScratchPad::setModeType(QString mode)
+{
+    if (mode.toLower() == "painting") {
+        m_toolMode = PAINTING;
+        setCursor(m_cursor);
+    }
+    else if (mode.toLower() == "panning") {
+        m_toolMode = PANNING;
+        setCursor(Qt::OpenHandCursor);
+    }
+    else if (mode.toLower() == "colorpicking") {
+        m_toolMode = PICKING;
+        setCursor(m_colorPickerCursor);
+    }
+}
+
 QImage KisScratchPad::cutoutOverlay() const
 {
     if(!m_paintLayer) return QImage();
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect rc = widgetToDocument().mapRect(m_cutoutOverlay);
     QImage rawImage = paintDevice->convertToQImage(0, rc.x(), rc.y(), rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
 
     QImage scaledImage = rawImage.scaled(m_cutoutOverlay.size(),
                                          Qt::IgnoreAspectRatio,
                                          Qt::SmoothTransformation);
 
     return scaledImage;
 }
 
 void KisScratchPad::setPresetImage(const QImage& image)
 {
     m_presetImage = image;
 }
 
 
 void KisScratchPad::paintCustomImage(const QImage& loadedImage)
 {
     // this is 99% copied from the normal paintPresetImage()
     // we don't want to save over the preset image, so we don't
     // want to store it in the m_presetImage
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = loadedImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.beginTransaction();
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     painter.deleteTransaction();
     update();
 }
 
 void KisScratchPad::paintPresetImage()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
 
     QRect overlayRect = widgetToDocument().mapRect(m_cutoutOverlay);
     QRect imageRect(QPoint(), overlayRect.size());
 
     QImage scaledImage = m_presetImage.scaled(overlayRect.size(),
                                               Qt::IgnoreAspectRatio,
                                               Qt::SmoothTransformation);
     KisPaintDeviceSP device = new KisPaintDevice(paintDevice->colorSpace());
     device->convertFromQImage(scaledImage, 0);
 
     KisPainter painter(paintDevice);
     painter.beginTransaction();
     painter.bitBlt(overlayRect.topLeft(), device, imageRect);
     painter.deleteTransaction();
     update();
 }
 
 void KisScratchPad::setDisplayProfile(const KoColorProfile *colorProfile)
 {
     if (colorProfile) {
         m_displayProfile = colorProfile;
         QWidget::update();
     }
 }
 
 void KisScratchPad::fillDefault()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KisTransaction t(paintDevice);
     paintDevice->setDefaultPixel(m_defaultColor);
     paintDevice->clear();
     t.end();
     update();
 }
 
 void KisScratchPad::fillTransparent() {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QColor transQColor(0,0,0,0);
     KoColor transparentColor(transQColor, KoColorSpaceRegistry::instance()->rgb8());
     transparentColor.setOpacity(0.0);
 
     KisTransaction t(paintDevice);
     paintDevice->setDefaultPixel(transparentColor);
     paintDevice->clear();
     t.end();
     update();
 }
 
 void KisScratchPad::fillGradient()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KoAbstractGradientSP gradient = m_resourceProvider->currentGradient();
     QRect gradientRect = widgetToDocument().mapRect(rect());
 
     KisTransaction t(paintDevice);
 
     paintDevice->clear();
 
     KisGradientPainter painter(paintDevice);
     painter.setGradient(gradient);
     painter.setGradientShape(KisGradientPainter::GradientShapeLinear);
     painter.paintGradient(gradientRect.topLeft(),
                           gradientRect.bottomRight(),
                           KisGradientPainter::GradientRepeatNone,
                           0.2, false,
                           gradientRect.left(), gradientRect.top(),
                           gradientRect.width(), gradientRect.height());
 
     t.end();
     update();
 }
 
 void KisScratchPad::fillBackground()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     KisTransaction t(paintDevice);
     paintDevice->setDefaultPixel(m_resourceProvider->bgColor());
     paintDevice->clear();
     t.end();
     update();
 }
 
 void KisScratchPad::fillLayer()
 {
     if(!m_paintLayer) return;
     KisPaintDeviceSP paintDevice = m_paintLayer->paintDevice();
 
     QRect sourceRect(0, 0, paintDevice->exactBounds().width(), paintDevice->exactBounds().height());
 
     KisPainter painter(paintDevice);
     painter.beginTransaction();
     painter.bitBlt(QPoint(0, 0), m_resourceProvider->currentImage()->projection(), sourceRect);
     painter.deleteTransaction();
     update();
 }
diff --git a/libs/ui/widgets/kis_scratch_pad.h b/libs/ui/widgets/kis_scratch_pad.h
index d920ec2327..42b2eb0b7c 100644
--- a/libs/ui/widgets/kis_scratch_pad.h
+++ b/libs/ui/widgets/kis_scratch_pad.h
@@ -1,181 +1,197 @@
 /* This file is part of the KDE project
  * Copyright 2010 (C) Boudewijn Rempt <boud@valdyas.org>
  * Copyright 2011 (C) Dmitry Kazakov <dimula73@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_SCRATCH_PAD_H
 #define KIS_SCRATCH_PAD_H
 
 #include <QImage>
 #include <QWidget>
 #include <QRect>
 
 #include <KoColor.h>
 
 
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_types.h>
 #include <kritaui_export.h>
 
 class QColor;
 
 class KoColorProfile;
 class KoPointerEvent;
 
 class KisCanvasResourceProvider;
 class KisUpdateScheduler;
 class KisUndoStore;
 class KisPostExecutionUndoAdapter;
 class KisScratchPadEventFilter;
 class KisPaintingInformationBuilder;
 class KisToolFreehandHelper;
 class KisNodeGraphListener;
 
 
 /**
  * A scratchpad is a painting canvas with only one zoomlevel and based on
  * a paint layer, not on a KisImage. It can have a blank, tiled background or
  * a gradient background.
  */
 class KRITAUI_EXPORT KisScratchPad : public QWidget
 {
 
     Q_OBJECT
 
 public:
     void setupScratchPad(KisCanvasResourceProvider* resourceProvider,
                          const QColor &defaultColor);
 
     KisScratchPad(QWidget *parent = 0);
     ~KisScratchPad() override;
 
     /// set the specified rect as the area taken for @see cutoutOverlay
     void setCutoutOverlayRect(const QRect&rc);
 
+    /**
+     * keep track of if our scratchpad is in paint, pan, or color pick mode
+     * Set to true if there is a GUI controlling current mode
+     * If this is false, the modes are only changed with various mouse click shortcuts
+     */
+    void setModeManually(bool value);
+
+    /**
+     * @brief change the mode explicitly to paint, mix, or pan
+     * @param what mode to change it to
+     */
+    void setModeType(QString modeName);
+
     /// return the contents of the area under the cutoutOverlay rect
     QImage cutoutOverlay() const;
 
     // A callback for our own node graph listener
     void imageUpdated(const QRect &rect);
 
     // A callback for scratch pad default bounds
     QRect imageBounds() const;
 
 
     // Called by the event filter
     void pointerPress(KoPointerEvent *event);
     void pointerRelease(KoPointerEvent *event);
     void pointerMove(KoPointerEvent *event);
 
 public Q_SLOTS:
     void fillDefault();
     void fillGradient();
     void fillBackground();
     void fillTransparent();
 
     /// Fill the area with what is on your current canvas
     void fillLayer();
 
 
     /**
      * Set the icon of the current preset
      */
     void setPresetImage(const QImage& image);
 
     /**
      * Paint the icon of the current preset inside the
      * cutout overlay
      *
      * \see setPresetImage
      */
     void paintPresetImage();
 
     /**
      * Paint the icon of a custom image that is being loaded
      *
      */
     void paintCustomImage(const QImage& loadedImage);
 
 private Q_SLOTS:
     void setOnScreenResolution(qreal scaleX, qreal scaleY);
     void setDisplayProfile(const KoColorProfile* colorProfile);
     void slotUpdateCanvas(const QRect &rect);
 
 Q_SIGNALS:
     void colorSelected(const KoColor& color);
     void sigUpdateCanvas(const QRect &rect);
 
 protected:
     void paintEvent ( QPaintEvent * event ) override;
 
 
 private:
     void beginStroke(KoPointerEvent *event);
     void doStroke(KoPointerEvent *event);
     void endStroke(KoPointerEvent *event);
 
     void beginPan(KoPointerEvent *event);
     void doPan(KoPointerEvent *event);
     void endPan(KoPointerEvent *event);
 
     void pick(KoPointerEvent *event);
 
     void updateTransformations();
 
     QTransform documentToWidget() const;
     QTransform widgetToDocument() const;
 
 private:
     enum Mode {
         PAINTING,
         HOVERING,
         PANNING,
         PICKING
     };
 
     Mode modeFromButton(Qt::MouseButton button) const;
 
 private:
 
     KoColor m_defaultColor;
     Mode m_toolMode;
+    bool isModeManuallySet = false;
+    bool isMouseDown = false;
     KisPaintLayerSP m_paintLayer;
     const KoColorProfile* m_displayProfile;
     QCursor m_cursor;
+    QCursor m_colorPickerCursor;
     QRect m_cutoutOverlay;
     QBrush m_checkBrush;
     KisCanvasResourceProvider* m_resourceProvider;
 
     KisUpdateScheduler *m_updateScheduler;
     KisUndoStore *m_undoStore;
     KisPostExecutionUndoAdapter *m_undoAdapter;
     KisNodeGraphListener *m_nodeListener;
     KisScratchPadEventFilter *m_eventFilter;
 
     QScopedPointer<KisToolFreehandHelper> m_helper;
     KisPaintingInformationBuilder *m_infoBuilder;
 
     QTransform m_scaleTransform;
     QTransform m_translateTransform;
 
     QPointF m_panDocPoint;
     int m_scaleBorderWidth;
 
     QImage m_presetImage;
 };
 
 #endif // KIS_SCRATCH_PAD_H
diff --git a/plugins/extensions/pykrita/sip/krita/Scratchpad.sip b/plugins/extensions/pykrita/sip/krita/Scratchpad.sip
index 490e0439a3..1210b0b6c9 100644
--- a/plugins/extensions/pykrita/sip/krita/Scratchpad.sip
+++ b/plugins/extensions/pykrita/sip/krita/Scratchpad.sip
@@ -1,10 +1,15 @@
 class Scratchpad : public QWidget /NoDefaultCtors/
 {
 %TypeHeaderCode
 #include "Scratchpad.h"
 %End
 
 public:
     Scratchpad(View* view , const QString & defaultColor, QWidget*  parent /TransferThis/ = 0);	
 		virtual ~Scratchpad();
+
+public Q_SLOTS:
+    void clear();
+    void setModeManually(bool value);
+    void setMode(QString modeName);
 };