diff --git a/libs/ui/tool/kis_tool_paint.cc b/libs/ui/tool/kis_tool_paint.cc
index ecdc74e9e5..84848152c6 100644
--- a/libs/ui/tool/kis_tool_paint.cc
+++ b/libs/ui/tool/kis_tool_paint.cc
@@ -1,782 +1,793 @@
 /*
  *  Copyright (c) 2003-2009 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2015 Moritz Molch <kde@moritzmolch.de>
  *
  *  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_paint.h"
 
 #include <algorithm>
 
 #include <QWidget>
 #include <QRect>
 #include <QLayout>
 #include <QLabel>
 #include <QPushButton>
 #include <QWhatsThis>
 #include <QCheckBox>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QVariant>
 #include <QAction>
 #include <kis_debug.h>
 #include <QPoint>
 
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <QAction>
 
 #include <kis_icon.h>
 #include <KoShape.h>
 #include <KoCanvasResourceManager.h>
 #include <KoColorSpace.h>
 #include <KoPointerEvent.h>
 #include <KoColor.h>
 #include <KoCanvasBase.h>
 #include <KoCanvasController.h>
 
 #include <kis_types.h>
 #include <kis_global.h>
 #include <kis_image.h>
 #include <kis_paint_device.h>
 #include <kis_layer.h>
 #include <KisViewManager.h>
 #include <kis_canvas2.h>
 #include <kis_cubic_curve.h>
 #include "kis_display_color_converter.h"
 
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_cursor.h"
 #include "widgets/kis_cmb_composite.h"
 #include "widgets/kis_slider_spin_box.h"
 #include "kis_canvas_resource_provider.h"
 #include <recorder/kis_recorded_paint_action.h>
 #include "kis_tool_utils.h"
 #include <brushengine/kis_paintop.h>
 #include <brushengine/kis_paintop_preset.h>
 #include <kis_action_manager.h>
 #include <kis_action.h>
 #include "strokes/kis_color_picker_stroke_strategy.h"
+#include <kis_canvas_resource_provider.h>
 
 
 KisToolPaint::KisToolPaint(KoCanvasBase * canvas, const QCursor & cursor)
     : KisTool(canvas, cursor),
       m_showColorPreview(false),
       m_colorPreviewShowComparePlate(false),
       m_colorPickerDelayTimer(),
       m_isOutlineEnabled(true)
 {
     m_specialHoverModifier = false;
     m_optionsWidgetLayout = 0;
 
     m_opacity = OPACITY_OPAQUE_U8;
 
     updateTabletPressureSamples();
 
     m_supportOutline = false;
 
     {
         int maxSize = KisConfig().readEntry("maximumBrushSize", 1000);
 
         int brushSize = 1;
         do {
             m_standardBrushSizes.push_back(brushSize);
             int increment = qMax(1, int(std::ceil(qreal(brushSize) / 15)));
             brushSize += increment;
         } while (brushSize < maxSize);
 
         m_standardBrushSizes.push_back(maxSize);
     }
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas);
     KisActionManager *actionManager = kiscanvas->viewManager()->actionManager();
 
     // XXX: Perhaps a better place for these?
     if (!actionManager->actionByName("increase_brush_size")) {
         KisAction *increaseBrushSize = new KisAction(i18n("Increase Brush Size"));
         increaseBrushSize->setShortcut(Qt::Key_BracketRight);
         actionManager->addAction("increase_brush_size", increaseBrushSize);
     }
 
     if (!actionManager->actionByName("decrease_brush_size")) {
         KisAction *decreaseBrushSize = new KisAction(i18n("Decrease Brush Size"));
         decreaseBrushSize->setShortcut(Qt::Key_BracketLeft);
         actionManager->addAction("decrease_brush_size", decreaseBrushSize);
     }
 
     addAction("increase_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("increase_brush_size")));
     addAction("decrease_brush_size", dynamic_cast<QAction *>(actionManager->actionByName("decrease_brush_size")));
 
     if (kiscanvas && kiscanvas->viewManager()) {
         connect(this, SIGNAL(sigPaintingFinished()), kiscanvas->viewManager()->resourceProvider(), SLOT(slotPainting()));
     }
 
     m_colorPickerDelayTimer.setSingleShot(true);
     connect(&m_colorPickerDelayTimer, SIGNAL(timeout()), this, SLOT(activatePickColorDelayed()));
 
     using namespace std::placeholders; // For _1 placeholder
     std::function<void(PickingJob)> callback =
         std::bind(&KisToolPaint::addPickerJob, this, _1);
     m_colorPickingCompressor.reset(
         new PickingCompressor(100, callback, KisSignalCompressor::FIRST_ACTIVE));
 }
 
 
 KisToolPaint::~KisToolPaint()
 {
 }
 
 int KisToolPaint::flags() const
 {
     return KisTool::FLAG_USES_CUSTOM_COMPOSITEOP;
 }
 
 void KisToolPaint::canvasResourceChanged(int key, const QVariant& v)
 {
     KisTool::canvasResourceChanged(key, v);
 
     switch(key) {
     case(KisCanvasResourceProvider::Opacity):
         setOpacity(v.toDouble());
         break;
     default: //nothing
         break;
     }
 
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(resetCursorStyle()), Qt::UniqueConnection);
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(updateTabletPressureSamples()), Qt::UniqueConnection);
 
 }
 
 
 void KisToolPaint::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     if (currentPaintOpPreset()) emit statusTextChanged(currentPaintOpPreset()->name());
     KisTool::activate(toolActivation, shapes);
     connect(action("increase_brush_size"), SIGNAL(triggered()), SLOT(increaseBrushSize()), Qt::UniqueConnection);
     connect(action("decrease_brush_size"), SIGNAL(triggered()), SLOT(decreaseBrushSize()), Qt::UniqueConnection);
+
+    KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
+    m_oldOpacity = provider->opacity();
+    provider->setOpacity(m_localOpacity);
 }
 
 void KisToolPaint::deactivate()
 {
+
     disconnect(action("increase_brush_size"), 0, this, 0);
     disconnect(action("decrease_brush_size"), 0, this, 0);
+
+    KisCanvasResourceProvider *provider = qobject_cast<KisCanvas2*>(canvas())->viewManager()->resourceProvider();
+    m_localOpacity = provider->opacity();
+    provider->setOpacity(m_oldOpacity);
+
     KisTool::deactivate();
 }
 
 QPainterPath KisToolPaint::tryFixBrushOutline(const QPainterPath &originalOutline)
 {
     KisConfig cfg;
     if (cfg.newOutlineStyle() == OUTLINE_NONE) return originalOutline;
 
     const qreal minThresholdSize = cfg.outlineSizeMinimum();
 
     /**
      * If the brush outline is bigger than the canvas itself (which
      * would make it invisible for a user in most of the cases) just
      * add a cross in the center of it
      */
 
     QSize widgetSize = canvas()->canvasWidget()->size();
     const int maxThresholdSum = widgetSize.width() + widgetSize.height();
 
     QPainterPath outline = originalOutline;
     QRectF boundingRect = outline.boundingRect();
     const qreal sum = boundingRect.width() + boundingRect.height();
 
     QPointF center = boundingRect.center();
 
     if (sum > maxThresholdSum) {
         const int hairOffset = 7;
 
         outline.moveTo(center.x(), center.y() - hairOffset);
         outline.lineTo(center.x(), center.y() + hairOffset);
 
         outline.moveTo(center.x() - hairOffset, center.y());
         outline.lineTo(center.x() + hairOffset, center.y());
     } else if (sum < minThresholdSize && !outline.isEmpty()) {
         outline = QPainterPath();
         outline.addEllipse(center, 0.5 * minThresholdSize, 0.5 * minThresholdSize);
     }
 
     return outline;
 }
 
 void KisToolPaint::paint(QPainter &gc, const KoViewConverter &converter)
 {
     Q_UNUSED(converter);
 
     QPainterPath path = tryFixBrushOutline(pixelToView(m_currentOutline));
     paintToolOutline(&gc, path);
 
     if (m_showColorPreview) {
         QRectF viewRect = converter.documentToView(m_oldColorPreviewRect);
         gc.fillRect(viewRect, m_colorPreviewCurrentColor);
 
         if (m_colorPreviewShowComparePlate) {
             QRectF baseColorRect = viewRect.translated(viewRect.width(), 0);
             gc.fillRect(baseColorRect, m_colorPreviewBaseColor);
         }
     }
 }
 
 void KisToolPaint::setMode(ToolMode mode)
 {
     if(this->mode() == KisTool::PAINT_MODE &&
             mode != KisTool::PAINT_MODE) {
 
         // Let's add history information about recently used colors
         emit sigPaintingFinished();
     }
 
     KisTool::setMode(mode);
 }
 
 void KisToolPaint::activatePickColor(AlternateAction action)
 {
     m_showColorPreview = true;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 
     int resource = colorPreviewResourceId(action);
     KoColor color = canvas()->resourceManager()->koColorResource(resource);
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
 
     m_colorPreviewCurrentColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     if (!m_colorPreviewBaseColor.isValid()) {
         m_colorPreviewBaseColor = m_colorPreviewCurrentColor;
     }
 }
 
 void KisToolPaint::deactivatePickColor(AlternateAction action)
 {
     Q_UNUSED(action);
 
     m_showColorPreview = false;
     m_oldColorPreviewRect = QRect();
     m_oldColorPreviewUpdateRect = QRect();
     m_colorPreviewCurrentColor = QColor();
 }
 
 void KisToolPaint::pickColorWasOverridden()
 {
     m_colorPreviewShowComparePlate = false;
     m_colorPreviewBaseColor = QColor();
 }
 
 void KisToolPaint::activateAlternateAction(AlternateAction action)
 {
     switch (action) {
     case PickFgNode:
     case PickBgNode:
     case PickFgImage:
     case PickBgImage:
         delayedAction = action;
         m_colorPickerDelayTimer.start(100);
     default:
         pickColorWasOverridden();
         KisTool::activateAlternateAction(action);
     };
 }
 
 void KisToolPaint::activatePickColorDelayed()
 {
     switch (delayedAction) {
         case PickFgNode:
         useCursor(KisCursor::pickerLayerForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgNode:
         useCursor(KisCursor::pickerLayerBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickFgImage:
         useCursor(KisCursor::pickerImageForegroundCursor());
         activatePickColor(delayedAction);
         break;
     case PickBgImage:
         useCursor(KisCursor::pickerImageBackgroundCursor());
         activatePickColor(delayedAction);
         break;
     default:
         break;
     };
 
     repaintDecorations();
 
 }
 
 bool KisToolPaint::isPickingAction(AlternateAction action) {
     return action == PickFgNode ||
         action == PickBgNode ||
         action == PickFgImage ||
         action == PickBgImage;
 }
 
 void KisToolPaint::deactivateAlternateAction(AlternateAction action)
 {
     if (!isPickingAction(action)) {
         KisTool::deactivateAlternateAction(action);
         return;
     }
 
     delayedAction = KisTool::NONE;
     m_colorPickerDelayTimer.stop();
 
     resetCursorStyle();
     deactivatePickColor(action);
 }
 
 void KisToolPaint::addPickerJob(const PickingJob &pickingJob)
 {
     /**
      * The actual picking is delayed by a compressor, so we can get this
      * event when the stroke is already closed
      */
     if (!m_pickerStrokeId) return;
 
     KIS_ASSERT_RECOVER_RETURN(isPickingAction(pickingJob.action));
 
     const QPoint imagePoint = image()->documentToIntPixel(pickingJob.documentPixel);
     const bool fromCurrentNode = pickingJob.action == PickFgNode || pickingJob.action == PickBgNode;
     m_pickingResource = colorPreviewResourceId(pickingJob.action);
 
     KisPaintDeviceSP device = fromCurrentNode ?
         currentNode()->projection() : image()->projection();
 
     image()->addJob(m_pickerStrokeId,
                     new KisColorPickerStrokeStrategy::Data(device, imagePoint));
 }
 
 void KisToolPaint::beginAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(!m_pickerStrokeId);
         setMode(SECONDARY_PAINT_MODE);
 
         KisColorPickerStrokeStrategy *strategy = new KisColorPickerStrokeStrategy();
         connect(strategy, &KisColorPickerStrokeStrategy::sigColorUpdated,
                 this, &KisToolPaint::slotColorPickingFinished);
 
         m_pickerStrokeId = image()->startStroke(strategy);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::beginAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::continueAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         m_colorPickingCompressor->start(PickingJob(event->point, action));
         requestUpdateOutline(event->point, event);
     } else {
         KisTool::continueAlternateAction(event, action);
     }
 }
 
 void KisToolPaint::endAlternateAction(KoPointerEvent *event, AlternateAction action)
 {
     if (isPickingAction(action)) {
         KIS_ASSERT_RECOVER_RETURN(m_pickerStrokeId);
         image()->endStroke(m_pickerStrokeId);
         m_pickerStrokeId.clear();
         requestUpdateOutline(event->point, event);
         setMode(HOVER_MODE);
     } else {
         KisTool::endAlternateAction(event, action);
     }
 }
 
 int KisToolPaint::colorPreviewResourceId(AlternateAction action)
 {
     bool toForegroundColor = action == PickFgNode || action == PickFgImage;
     int resource = toForegroundColor ?
         KoCanvasResourceManager::ForegroundColor : KoCanvasResourceManager::BackgroundColor;
 
     return resource;
 }
 
 void KisToolPaint::slotColorPickingFinished(const KoColor &color)
 {
     canvas()->resourceManager()->setResource(m_pickingResource, color);
 
     if (!m_showColorPreview) return;
 
     KisCanvas2 * kisCanvas = dynamic_cast<KisCanvas2*>(canvas());
     KIS_ASSERT_RECOVER_RETURN(kisCanvas);
     QColor previewColor = kisCanvas->displayColorConverter()->toQColor(color);
 
     m_colorPreviewShowComparePlate = true;
     m_colorPreviewCurrentColor = previewColor;
 
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::mousePressEvent(KoPointerEvent *event)
 {
     KisTool::mousePressEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseMoveEvent(KoPointerEvent *event)
 {
     KisTool::mouseMoveEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 void KisToolPaint::mouseReleaseEvent(KoPointerEvent *event)
 {
     KisTool::mouseReleaseEvent(event);
     if (mode() == KisTool::HOVER_MODE) {
         requestUpdateOutline(event->point, event);
     }
 }
 
 QWidget * KisToolPaint::createOptionWidget()
 {
     QWidget * optionWidget = new QWidget();
     optionWidget->setObjectName(toolId());
 
     QVBoxLayout* verticalLayout = new QVBoxLayout(optionWidget);
     verticalLayout->setObjectName("KisToolPaint::OptionWidget::VerticalLayout");
     verticalLayout->setContentsMargins(0,0,0,0);
     verticalLayout->setSpacing(5);
 
     // See https://bugs.kde.org/show_bug.cgi?id=316896
     QWidget *specialSpacer = new QWidget(optionWidget);
     specialSpacer->setObjectName("SpecialSpacer");
     specialSpacer->setFixedSize(0, 0);
     verticalLayout->addWidget(specialSpacer);
     verticalLayout->addWidget(specialSpacer);
 
     m_optionsWidgetLayout = new QGridLayout();
     m_optionsWidgetLayout->setColumnStretch(1, 1);
 
     verticalLayout->addLayout(m_optionsWidgetLayout);
     m_optionsWidgetLayout->setContentsMargins(0,0,0,0);
     m_optionsWidgetLayout->setSpacing(5);
 
     if (!quickHelp().isEmpty()) {
         QPushButton* push = new QPushButton(KisIconUtils::loadIcon("help-contents"), QString(), optionWidget);
         connect(push, SIGNAL(clicked()), this, SLOT(slotPopupQuickHelp()));
 
         QHBoxLayout* hLayout = new QHBoxLayout(optionWidget);
         hLayout->addWidget(push);
         hLayout->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
         verticalLayout->addLayout(hLayout);
     }
 
     return optionWidget;
 }
 
 QWidget* findLabelWidget(QGridLayout *layout, QWidget *control)
 {
     QWidget *result = 0;
 
     int index = layout->indexOf(control);
 
     int row, col, rowSpan, colSpan;
     layout->getItemPosition(index, &row, &col, &rowSpan, &colSpan);
 
     if (col > 0) {
         QLayoutItem *item = layout->itemAtPosition(row, col - 1);
 
         if (item) {
             result = item->widget();
         }
     } else {
         QLayoutItem *item = layout->itemAtPosition(row, col + 1);
         if (item) {
             result = item->widget();
         }
     }
 
     return result;
 }
 
 void KisToolPaint::showControl(QWidget *control, bool value)
 {
     control->setVisible(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setVisible(value);
     }
 }
 
 void KisToolPaint::enableControl(QWidget *control, bool value)
 {
     control->setEnabled(value);
     QWidget *label = findLabelWidget(m_optionsWidgetLayout, control);
     if (label) {
         label->setEnabled(value);
     }
 }
 
 void KisToolPaint::addOptionWidgetLayout(QLayout *layout)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     int rowCount = m_optionsWidgetLayout->rowCount();
     m_optionsWidgetLayout->addLayout(layout, rowCount, 0, 1, 2);
 }
 
 
 void KisToolPaint::addOptionWidgetOption(QWidget *control, QWidget *label)
 {
     Q_ASSERT(m_optionsWidgetLayout != 0);
     if (label) {
         m_optionsWidgetLayout->addWidget(label, m_optionsWidgetLayout->rowCount(), 0);
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount() - 1, 1);
     }
     else {
         m_optionsWidgetLayout->addWidget(control, m_optionsWidgetLayout->rowCount(), 0, 1, 2);
     }
 }
 
 
 void KisToolPaint::setOpacity(qreal opacity)
 {
     m_opacity = quint8(opacity * OPACITY_OPAQUE_U8);
 }
 
 const KoCompositeOp* KisToolPaint::compositeOp()
 {
     if (currentNode()) {
         KisPaintDeviceSP device = currentNode()->paintDevice();
         if (device) {
             QString op = canvas()->resourceManager()->resource(KisCanvasResourceProvider::CurrentCompositeOp).toString();
             return device->colorSpace()->compositeOp(op);
         }
     }
     return 0;
 }
 
 void KisToolPaint::slotPopupQuickHelp()
 {
     QWhatsThis::showText(QCursor::pos(), quickHelp());
 }
 
 void KisToolPaint::updateTabletPressureSamples()
 {
     KisConfig cfg;
     KisCubicCurve curve;
     curve.fromString(cfg.pressureTabletCurve());
     m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1);
 }
 
 void KisToolPaint::setupPaintAction(KisRecordedPaintAction* action)
 {
     KisTool::setupPaintAction(action);
     action->setOpacity(m_opacity / qreal(255.0));
     const KoCompositeOp* op = compositeOp();
     if (op) {
         action->setCompositeOp(op->id());
     }
 }
 
 KisToolPaint::NodePaintAbility KisToolPaint::nodePaintAbility()
 {
     KisNodeSP node = currentNode();
     if (!node) {
         return NONE;
     }
     if (node->inherits("KisShapeLayer")) {
         return VECTOR;
     }
     if (node->paintDevice()) {
         return PAINT;
     }
     return NONE;
 }
 
 void KisToolPaint::activatePrimaryAction()
 {
     pickColorWasOverridden();
     setOutlineEnabled(true);
     KisTool::activatePrimaryAction();
 }
 
 void KisToolPaint::deactivatePrimaryAction()
 {
     setOutlineEnabled(false);
     KisTool::deactivatePrimaryAction();
 }
 
 bool KisToolPaint::isOutlineEnabled() const
 {
     return m_isOutlineEnabled;
 }
 
 void KisToolPaint::setOutlineEnabled(bool value)
 {
     m_isOutlineEnabled = value;
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::increaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::iterator result =
         std::upper_bound(m_standardBrushSizes.begin(),
                          m_standardBrushSizes.end(),
                          qRound(paintopSize));
 
     int newValue = result != m_standardBrushSizes.end() ? *result : m_standardBrushSizes.back();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 void KisToolPaint::decreaseBrushSize()
 {
     qreal paintopSize = currentPaintOpPreset()->settings()->paintOpSize();
 
     std::vector<int>::reverse_iterator result =
         std::upper_bound(m_standardBrushSizes.rbegin(),
                          m_standardBrushSizes.rend(),
                          (int)paintopSize,
                          std::greater<int>());
 
     int newValue = result != m_standardBrushSizes.rend() ? *result : m_standardBrushSizes.front();
 
     currentPaintOpPreset()->settings()->setPaintOpSize(newValue);
     requestUpdateOutline(m_outlineDocPoint, 0);
 }
 
 QRectF KisToolPaint::colorPreviewDocRect(const QPointF &outlineDocPoint)
 {
     if (!m_showColorPreview) return QRect();
 
     KisConfig cfg;
 
     const QRectF colorPreviewViewRect = cfg.colorPreviewRect();
     const QRectF colorPreviewDocumentRect = canvas()->viewConverter()->viewToDocument(colorPreviewViewRect);
 
     return colorPreviewDocumentRect.translated(outlineDocPoint);
 }
 
 void KisToolPaint::requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event)
 {
     if (!m_supportOutline) return;
 
     KisConfig cfg;
     KisPaintOpSettings::OutlineMode outlineMode;
     outlineMode = KisPaintOpSettings::CursorNoOutline;
 
     if (isOutlineEnabled() &&
         (mode() == KisTool::GESTURE_MODE ||
          ((cfg.newOutlineStyle() == OUTLINE_FULL ||
            cfg.newOutlineStyle() == OUTLINE_CIRCLE ||
            cfg.newOutlineStyle() == OUTLINE_TILT ||
            cfg.newOutlineStyle() == OUTLINE_COLOR ) &&
           ((mode() == HOVER_MODE) ||
            (mode() == PAINT_MODE && cfg.showOutlineWhilePainting()))))) { // lisp forever!
 
         if(cfg.newOutlineStyle() == OUTLINE_CIRCLE) {
             outlineMode = KisPaintOpSettings::CursorIsCircleOutline;
         } else if(cfg.newOutlineStyle() == OUTLINE_TILT) {
             outlineMode = KisPaintOpSettings::CursorTiltOutline;
         } else if(cfg.newOutlineStyle() == OUTLINE_COLOR) {
             outlineMode = KisPaintOpSettings::CursorColorOutline;
         } else {
             outlineMode = KisPaintOpSettings::CursorIsOutline;
         }
     }
 
     m_outlineDocPoint = outlineDocPoint;
     m_currentOutline = getOutlinePath(m_outlineDocPoint, event, outlineMode);
 
     QRectF outlinePixelRect = m_currentOutline.boundingRect();
     QRectF outlineDocRect = currentImage()->pixelToDocument(outlinePixelRect);
 
     // This adjusted call is needed as we paint with a 3 pixel wide brush and the pen is outside the bounds of the path
     // Pen uses view coordinates so we have to zoom the document value to match 2 pixel in view coordiates
     // See BUG 275829
     qreal zoomX;
     qreal zoomY;
     canvas()->viewConverter()->zoom(&zoomX, &zoomY);
     qreal xoffset = 2.0/zoomX;
     qreal yoffset = 2.0/zoomY;
 
     if (!outlineDocRect.isEmpty()) {
         outlineDocRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     QRectF colorPreviewDocRect = this->colorPreviewDocRect(m_outlineDocPoint);
     QRectF colorPreviewDocUpdateRect;
     if (!colorPreviewDocRect.isEmpty()) {
         colorPreviewDocUpdateRect.adjust(-xoffset,-yoffset,xoffset,yoffset);
     }
 
     // DIRTY HACK ALERT: we should fetch the assistant's dirty rect when requesting
     //                   the update, instead of just dumbly update the entire canvas!
 
     KisCanvas2 * kiscanvas = dynamic_cast<KisCanvas2*>(canvas());
     KisPaintingAssistantsDecorationSP decoration = kiscanvas->paintingAssistantsDecoration();
     if (decoration && decoration->visible()) {
         kiscanvas->updateCanvas();
     } else {
         // TODO: only this branch should be present!
         if (!m_oldColorPreviewUpdateRect.isEmpty()) {
             canvas()->updateCanvas(m_oldColorPreviewUpdateRect);
         }
 
         if (!m_oldOutlineRect.isEmpty()) {
             canvas()->updateCanvas(m_oldOutlineRect);
         }
 
         if (!outlineDocRect.isEmpty()) {
             canvas()->updateCanvas(outlineDocRect);
         }
 
         if (!colorPreviewDocUpdateRect.isEmpty()) {
             canvas()->updateCanvas(colorPreviewDocUpdateRect);
         }
     }
 
     m_oldOutlineRect = outlineDocRect;
     m_oldColorPreviewRect = colorPreviewDocRect;
     m_oldColorPreviewUpdateRect = colorPreviewDocUpdateRect;
 }
 
 QPainterPath KisToolPaint::getOutlinePath(const QPointF &documentPos,
                                           const KoPointerEvent *event,
                                           KisPaintOpSettings::OutlineMode outlineMode)
 {
     Q_UNUSED(event);
 
     QPointF imagePos = currentImage()->documentToPixel(documentPos);
     QPainterPath path = currentPaintOpPreset()->settings()->
         brushOutline(KisPaintInformation(imagePos), outlineMode);
 
     return path;
 }
 
diff --git a/libs/ui/tool/kis_tool_paint.h b/libs/ui/tool/kis_tool_paint.h
index d7eae7272f..609199ec07 100644
--- a/libs/ui/tool/kis_tool_paint.h
+++ b/libs/ui/tool/kis_tool_paint.h
@@ -1,236 +1,239 @@
 /*
  *  Copyright (c) 2003 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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_PAINT_H_
 #define KIS_TOOL_PAINT_H_
 
 #include <vector>
 
 #include <QCursor>
 #include <QLayout>
 #include <QGridLayout>
 #include <QVariant>
 #include <QTimer>
 
 #include <KoCanvasResourceManager.h>
 #include <KoToolBase.h>
 #include <resources/KoAbstractGradient.h>
 
 #include <kritaui_export.h>
 
 #include <kis_types.h>
 #include <kis_image.h>
 #include "kis_signal_compressor_with_param.h"
 #include <brushengine/kis_paintop_settings.h>
 
 #include <resources/KoPattern.h>
 
 #include "kis_tool.h"
 #include <QCheckBox>
 
 class QGridLayout;
 class KoCompositeOp;
 
 
 class KoCanvasBase;
 
 
 // wacom
 const static int LEVEL_OF_PRESSURE_RESOLUTION = 1024;
 
 class KRITAUI_EXPORT KisToolPaint : public KisTool
 {
 
     Q_OBJECT
 
 public:
     KisToolPaint(KoCanvasBase * canvas, const QCursor & cursor);
     ~KisToolPaint() override;
     int flags() const override;
 
     void mousePressEvent(KoPointerEvent *event) override;
     void mouseReleaseEvent(KoPointerEvent *event) override;
     void mouseMoveEvent(KoPointerEvent *event) override;
 
 protected:
 
     void setMode(ToolMode mode) override;
 
     void canvasResourceChanged(int key, const QVariant & v) override;
 
     void paint(QPainter& gc, const KoViewConverter &converter) override;
 
     void activatePrimaryAction() override;
     void deactivatePrimaryAction() override;
 
     void activateAlternateAction(AlternateAction action) override;
     void deactivateAlternateAction(AlternateAction action) override;
 
     void beginAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void continueAlternateAction(KoPointerEvent *event, AlternateAction action) override;
     void endAlternateAction(KoPointerEvent *event, AlternateAction action) override;
 
     virtual void requestUpdateOutline(const QPointF &outlineDocPoint, const KoPointerEvent *event);
 
     /** If the paint tool support outline like brushes, set to true.
     *   If not (e.g. gradient tool), set to false. Default is false.
     */
     void setSupportOutline(bool supportOutline) {
         m_supportOutline = supportOutline;
     }
 
     virtual QPainterPath getOutlinePath(const QPointF &documentPos,
                                         const KoPointerEvent *event,
                                         KisPaintOpSettings::OutlineMode outlineMode);
 
 protected:
     bool isOutlineEnabled() const;
     void setOutlineEnabled(bool enabled);
 
     bool pickColor(const QPointF &documentPixel, AlternateAction action);
 
     /// Add the tool-specific layout to the default option widget layout.
     void addOptionWidgetLayout(QLayout *layout);
 
     /// Add a widget and a label to the current option widget layout.
     virtual void addOptionWidgetOption(QWidget *control, QWidget *label = 0);
 
     void showControl(QWidget *control, bool value);
     void enableControl(QWidget *control, bool value);
 
     QWidget * createOptionWidget() override;
 
     /**
      * Quick help is a short help text about the way the tool functions.
      */
     virtual QString quickHelp() const {
         return QString();
     }
 
     void setupPaintAction(KisRecordedPaintAction* action) override;
 
     qreal pressureToCurve(qreal pressure){
         qreal p =  qRound(pressure * LEVEL_OF_PRESSURE_RESOLUTION);
         if (p < 0) {
             return m_pressureSamples.first();
         }
         else if (p < m_pressureSamples.size()) {
             return m_pressureSamples.at(p);
         }
         return m_pressureSamples.last();
     }
 
     enum NodePaintAbility {
         NONE,
         PAINT,
         VECTOR
     };
 
     /// Checks if and how the tool can paint on the current node
     NodePaintAbility nodePaintAbility();
 
     const KoCompositeOp* compositeOp();
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
     void deactivate() override;
 
 private Q_SLOTS:
 
     void slotPopupQuickHelp();
 
     void increaseBrushSize();
     void decreaseBrushSize();
 
     void activatePickColorDelayed();
 
     void slotColorPickingFinished(const KoColor &color);
 
 protected Q_SLOTS:
     void updateTabletPressureSamples();
 
 protected:
     quint8 m_opacity;
     bool m_paintOutline;
     QVector<qreal> m_pressureSamples;
     QPointF m_outlineDocPoint;
     QPainterPath m_currentOutline;
     QRectF m_oldOutlineRect;
 
     bool m_showColorPreview;
     QRectF m_oldColorPreviewRect;
     QRectF m_oldColorPreviewUpdateRect;
     QColor m_colorPreviewCurrentColor;
     bool m_colorPreviewShowComparePlate;
     QColor m_colorPreviewBaseColor;
 
 private:
     QPainterPath tryFixBrushOutline(const QPainterPath &originalOutline);
     void setOpacity(qreal opacity);
 
     void activatePickColor(AlternateAction action);
     void deactivatePickColor(AlternateAction action);
     void pickColorWasOverridden();
 
     int colorPreviewResourceId(AlternateAction action);
     QRectF colorPreviewDocRect(const QPointF &outlineDocPoint);
 
     bool isPickingAction(AlternateAction action);
 
 
     struct PickingJob {
         PickingJob() {}
         PickingJob(QPointF _documentPixel,
                    AlternateAction _action)
             : documentPixel(_documentPixel),
               action(_action) {}
 
         QPointF documentPixel;
         AlternateAction action;
     };
     void addPickerJob(const PickingJob &pickingJob);
 
 private:
 
     bool m_specialHoverModifier;
     QGridLayout *m_optionsWidgetLayout;
 
     bool m_supportOutline;
 
     /**
      * Used as a switch for pickColor
      */
 
     // used to skip some of the tablet events and don't update the colour that often
     QTimer m_colorPickerDelayTimer;
     AlternateAction delayedAction;
 
     bool m_isOutlineEnabled;
     std::vector<int> m_standardBrushSizes;
 
     KisStrokeId m_pickerStrokeId;
     int m_pickingResource;
     typedef KisSignalCompressorWithParam<PickingJob> PickingCompressor;
     QScopedPointer<PickingCompressor> m_colorPickingCompressor;
 
+    qreal m_localOpacity {1.0};
+    qreal m_oldOpacity {1.0};
+
 Q_SIGNALS:
     void sigPaintingFinished();
 };
 
 #endif // KIS_TOOL_PAINT_H_
 
diff --git a/plugins/tools/basictools/kis_tool_gradient.cc b/plugins/tools/basictools/kis_tool_gradient.cc
index d18aad3f94..0354591780 100644
--- a/plugins/tools/basictools/kis_tool_gradient.cc
+++ b/plugins/tools/basictools/kis_tool_gradient.cc
@@ -1,299 +1,304 @@
 /*
  *  kis_tool_gradient.cc - part of Krita
  *
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2003 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004-2007 Adrian Page <adrian@pagenet.plus.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_gradient.h"
 
 #include <cfloat>
 
 #include <QApplication>
 #include <QPainter>
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 
 #include <kis_transaction.h>
 #include <kis_debug.h>
 #include <klocalizedstring.h>
 #include <kcombobox.h>
 
 
 #include <KoPointerEvent.h>
 #include <KoCanvasBase.h>
 #include <KoViewConverter.h>
 #include <KoUpdater.h>
 #include <KoProgressUpdater.h>
 
 #include <kis_gradient_painter.h>
 #include <kis_painter.h>
 #include <kis_canvas_resource_provider.h>
 #include <kis_layer.h>
 #include <kis_selection.h>
 #include <kis_paint_layer.h>
 
 #include <canvas/kis_canvas2.h>
 #include <KisViewManager.h>
 #include <widgets/kis_cmb_composite.h>
 #include <widgets/kis_double_widget.h>
 #include <widgets/kis_slider_spin_box.h>
 #include <kis_cursor.h>
 #include <kis_config.h>
 #include "kis_resources_snapshot.h"
 
 
 KisToolGradient::KisToolGradient(KoCanvasBase * canvas)
         : KisToolPaint(canvas, KisCursor::load("tool_gradient_cursor.png", 6, 6))
 {
     setObjectName("tool_gradient");
 
     m_startPos = QPointF(0, 0);
     m_endPos = QPointF(0, 0);
 
     m_reverse = false;
     m_shape = KisGradientPainter::GradientShapeLinear;
     m_repeat = KisGradientPainter::GradientRepeatNone;
     m_antiAliasThreshold = 0.2;
 }
 
 KisToolGradient::~KisToolGradient()
 {
 }
 
 void KisToolGradient::resetCursorStyle()
 {
     KisToolPaint::resetCursorStyle();
 
     overrideCursorIfNotEditable();
 }
 
 void KisToolGradient::activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes)
 {
     KisToolPaint::activate(toolActivation, shapes);
     m_configGroup =  KSharedConfig::openConfig()->group(toolId());
 }
 
 void KisToolGradient::paint(QPainter &painter, const KoViewConverter &converter)
 {
     if (mode() == KisTool::PAINT_MODE && m_startPos != m_endPos) {
             qreal sx, sy;
             converter.zoom(&sx, &sy);
             painter.scale(sx / currentImage()->xRes(), sy / currentImage()->yRes());
             paintLine(painter);
     }
 }
 
 void KisToolGradient::beginPrimaryAction(KoPointerEvent *event)
 {
     if (!nodeEditable()) {
         event->ignore();
         return;
     }
 
     setMode(KisTool::PAINT_MODE);
 
     m_startPos = convertToPixelCoordAndSnap(event, QPointF(), false);
     m_endPos = m_startPos;
 }
 
 void KisToolGradient::continuePrimaryAction(KoPointerEvent *event)
 {
     /**
      * TODO: The gradient tool is still not in strokes, so the end of
      *       its action can call processEvent(), which would result in
      *       nested event hadler calls. Please uncomment this line
      *       when the tool is ported to strokes.
      */
     //CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
 
     QPointF pos = convertToPixelCoordAndSnap(event, QPointF(), false);
 
     QRectF bound(m_startPos, m_endPos);
     canvas()->updateCanvas(convertToPt(bound.normalized()));
 
     if (event->modifiers() == Qt::ShiftModifier) {
         m_endPos = straightLine(pos);
     } else {
         m_endPos = pos;
     }
 
     bound.setTopLeft(m_startPos);
     bound.setBottomRight(m_endPos);
     canvas()->updateCanvas(convertToPt(bound.normalized()));
 }
 
 void KisToolGradient::endPrimaryAction(KoPointerEvent *event)
 {
     Q_UNUSED(event);
     CHECK_MODE_SANITY_OR_RETURN(KisTool::PAINT_MODE);
     setMode(KisTool::HOVER_MODE);
 
     if (!currentNode() || !blockUntilOperationsFinished())
         return;
 
     if (m_startPos == m_endPos) {
         return;
     }
 
     KisPaintDeviceSP device;
     KisImageSP image = this->image();
 
     KisResourcesSnapshotSP resources =
         new KisResourcesSnapshot(image, currentNode(), this->canvas()->resourceManager());
 
     if (image && (device = resources->currentNode()->paintDevice())) {
         QApplication::setOverrideCursor(Qt::BusyCursor);
 
         KUndo2MagicString actionName = kundo2_i18n("Gradient");
         KisUndoAdapter *undoAdapter = image->undoAdapter();
         undoAdapter->beginMacro(actionName);
 
         KisGradientPainter painter(device, resources->activeSelection());
         resources->setupPainter(&painter);
 
         painter.beginTransaction();
 
         KisCanvas2 * canvas = dynamic_cast<KisCanvas2 *>(this->canvas());
         KoUpdaterPtr updater = canvas->viewManager()->createUnthreadedUpdater(i18nc("@info:progress", "Gradient..."));
 
         painter.setProgress(updater);
 
         painter.setGradientShape(m_shape);
         painter.paintGradient(m_startPos, m_endPos, m_repeat, m_antiAliasThreshold, m_reverse, 0, 0, image->width(), image->height());
         painter.endTransaction(undoAdapter);
         undoAdapter->endMacro();
 
         QApplication::restoreOverrideCursor();
         currentNode()->setDirty();
         notifyModified();
     }
     canvas()->updateCanvas(convertToPt(currentImage()->bounds()));
 }
 
 QPointF KisToolGradient::straightLine(QPointF point)
 {
     QPointF comparison = point - m_startPos;
     QPointF result;
 
     if (fabs(comparison.x()) > fabs(comparison.y())) {
         result.setX(point.x());
         result.setY(m_startPos.y());
     } else {
         result.setX(m_startPos.x());
         result.setY(point.y());
     }
 
     return result;
 }
 
 void KisToolGradient::paintLine(QPainter& gc)
 {
     if (canvas()) {
         QPen old = gc.pen();
         QPen pen(Qt::SolidLine);
 
         gc.setPen(pen);
         gc.drawLine(m_startPos, m_endPos);
         gc.setPen(old);
     }
 }
 
 QWidget* KisToolGradient::createOptionWidget()
 {
     QWidget *widget = KisToolPaint::createOptionWidget();
     Q_CHECK_PTR(widget);
     widget->setObjectName(toolId() + " option widget");
 
 
     // Make sure to create the connections last after everything is set up. The initialized values
     // won't be loaded from the configuration file if you add the widget before the connection
     m_lbShape = new QLabel(i18n("Shape:"), widget);
     m_cmbShape = new KComboBox(widget);
     m_cmbShape->setObjectName("shape_combo");
     m_cmbShape->addItem(i18nc("the gradient will be drawn linearly", "Linear"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn bilinearly", "Bi-Linear"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn radially", "Radial"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn in a square around a centre", "Square"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn as an assymmetric cone", "Conical"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn as a symmetric cone", "Conical Symmetric"));
     m_cmbShape->addItem(i18nc("the gradient will be drawn in a selection outline", "Shaped"));
     addOptionWidgetOption(m_cmbShape, m_lbShape);
     connect(m_cmbShape, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetShape(int)));
 
     m_lbRepeat = new QLabel(i18n("Repeat:"), widget);
     m_cmbRepeat = new KComboBox(widget);
     m_cmbRepeat->setObjectName("repeat_combo");
     m_cmbRepeat->addItem(i18nc("The gradient will not repeat", "None"));
     m_cmbRepeat->addItem(i18nc("The gradient will repeat forwards", "Forwards"));
     m_cmbRepeat->addItem(i18nc("The gradient will repeat alternatingly", "Alternating"));
     addOptionWidgetOption(m_cmbRepeat, m_lbRepeat);
     connect(m_cmbRepeat, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSetRepeat(int)));
 
 
     m_lbAntiAliasThreshold = new QLabel(i18n("Anti-alias threshold:"), widget);
     m_slAntiAliasThreshold = new KisDoubleSliderSpinBox(widget);
     m_slAntiAliasThreshold->setObjectName("threshold_slider");
     m_slAntiAliasThreshold->setRange(0, 1, 3);
     addOptionWidgetOption(m_slAntiAliasThreshold, m_lbAntiAliasThreshold);
     connect(m_slAntiAliasThreshold, SIGNAL(valueChanged(qreal)), this, SLOT(slotSetAntiAliasThreshold(qreal)));
 
     m_ckReverse = new QCheckBox(i18nc("the gradient will be drawn with the color order reversed", "Reverse"), widget);
     m_ckReverse->setObjectName("reverse_check");
     connect(m_ckReverse, SIGNAL(toggled(bool)), this, SLOT(slotSetReverse(bool)));
     addOptionWidgetOption(m_ckReverse);
 
 
     widget->setFixedHeight(widget->sizeHint().height());
 
 
     // load configuration settings into widget (updating UI will update internal variables from signals/slots)
     m_ckReverse->setChecked((bool)m_configGroup.readEntry("reverse", false));
     m_cmbShape->setCurrentIndex((int)m_configGroup.readEntry("shape", 0));
     m_cmbRepeat->setCurrentIndex((int)m_configGroup.readEntry("repeat", 0));
     m_slAntiAliasThreshold->setValue((qreal)m_configGroup.readEntry("antialiasThreshold", 0.0));
 
     return widget;
 }
 
 void KisToolGradient::slotSetShape(int shape)
 {
     m_shape = static_cast<KisGradientPainter::enumGradientShape>(shape);
     m_configGroup.writeEntry("shape", shape);
 }
 
 void KisToolGradient::slotSetRepeat(int repeat)
 {
     m_repeat = static_cast<KisGradientPainter::enumGradientRepeat>(repeat);
     m_configGroup.writeEntry("repeat", repeat);
 }
 
 void KisToolGradient::slotSetReverse(bool state)
 {
     m_reverse = state;
     m_configGroup.writeEntry("reverse", state);
 }
 
 void KisToolGradient::slotSetAntiAliasThreshold(qreal value)
 {
     m_antiAliasThreshold = value;
     m_configGroup.writeEntry("antialiasThreshold", value);
 }
 
+void KisToolGradient::setOpacity(qreal opacity)
+{
+    m_opacity = opacity;
+}
+
 
diff --git a/plugins/tools/basictools/kis_tool_gradient.h b/plugins/tools/basictools/kis_tool_gradient.h
index ab68fd864d..700297d57b 100644
--- a/plugins/tools/basictools/kis_tool_gradient.h
+++ b/plugins/tools/basictools/kis_tool_gradient.h
@@ -1,131 +1,131 @@
 /*
  *  kis_tool_line.h - part of Krayon
  *
  *  Copyright (c) 2000 John Califf <jcaliff@comuzone.net>
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
  *  Copyright (c) 2004 Adrian Page <adrian@pagenet.plus.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_GRADIENT_H_
 #define KIS_TOOL_GRADIENT_H_
 
 #include <QKeySequence>
 
 #include <KoToolFactoryBase.h>
 
 #include <kis_tool_paint.h>
 #include <kis_global.h>
 #include <kis_types.h>
 #include <kis_gradient_painter.h>
 #include <flake/kis_node_shape.h>
 #include <kis_icon.h>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 
 
 class QLabel;
 class QPoint;
 class QWidget;
 class QCheckBox;
 class KComboBox;
 class KisDoubleSliderSpinBox;
 
 class KisToolGradient : public KisToolPaint
 {
 
     Q_OBJECT
 
 public:
     KisToolGradient(KoCanvasBase * canvas);
     ~KisToolGradient() override;
 
     void beginPrimaryAction(KoPointerEvent *event) override;
     void continuePrimaryAction(KoPointerEvent *event) override;
     void endPrimaryAction(KoPointerEvent *event) override;
 
     void paint(QPainter &painter, const KoViewConverter &converter) override;
 
     QWidget* createOptionWidget() override;
 
 public Q_SLOTS:
     void activate(ToolActivation toolActivation, const QSet<KoShape*> &shapes) override;
+private Q_SLOTS:
     void slotSetShape(int);
     void slotSetRepeat(int);
     void slotSetReverse(bool);
     void slotSetAntiAliasThreshold(qreal);
-
+    void setOpacity(qreal opacity);
 protected Q_SLOTS:
     void resetCursorStyle() override;
 
 private Q_SLOTS:
 
     void areaDone(const QRect & rc) {
         currentNode()->setDirty(rc); // Starts computing the projection for the area we've done.
 
     }
 
 private:
 
     void paintLine(QPainter& gc);
 
     QPointF straightLine(QPointF point);
 
     QPointF m_startPos;
     QPointF m_endPos;
 
     KisGradientPainter::enumGradientShape m_shape;
     KisGradientPainter::enumGradientRepeat m_repeat;
 
     bool m_reverse;
     double m_antiAliasThreshold;
 
     QLabel *m_lbShape;
     QLabel *m_lbRepeat;
     QCheckBox *m_ckReverse;
     KComboBox *m_cmbShape;
     KComboBox *m_cmbRepeat;
     QLabel *m_lbAntiAliasThreshold;
     KisDoubleSliderSpinBox *m_slAntiAliasThreshold;
     KConfigGroup m_configGroup;
-
 };
 
 class KisToolGradientFactory : public KoToolFactoryBase
 {
 
 public:
     KisToolGradientFactory()
             : KoToolFactoryBase("KritaFill/KisToolGradient") {
         setToolTip(i18n("Gradient Tool"));
         setSection(TOOL_TYPE_FILL);
         setIconName(koIconNameCStr("krita_tool_gradient"));
         setShortcut(QKeySequence(Qt::Key_G));
         setPriority(1);
         setActivationShapeId(KRITA_TOOL_ACTIVATION_ID);
     }
 
     ~KisToolGradientFactory() override {}
 
     KoToolBase * createTool(KoCanvasBase *canvas) override {
         return  new KisToolGradient(canvas);
     }
 
 };
 
 #endif //KIS_TOOL_GRADIENT_H_