diff --git a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
index 2d378181f5..fb4e3c612e 100644
--- a/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
+++ b/plugins/paintops/libpaintop/kis_brush_based_paintop_settings.cpp
@@ -1,340 +1,342 @@
 /*
  *  Copyright (c) 2010 Sven Langkamp <sven.langkamp@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_brush_based_paintop_settings.h"
 
 #include <kis_paint_action_type_option.h>
 #include <kis_airbrush_option.h>
 #include "kis_brush_based_paintop_options_widget.h"
 #include <kis_boundary.h>
 #include "kis_brush_server.h"
 #include <QLineF>
 #include "kis_signals_blocker.h"
 #include "kis_brush_option.h"
 
 struct BrushReader {
     BrushReader(const KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     const KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 struct BrushWriter {
     BrushWriter(KisBrushBasedPaintOpSettings *parent)
         : m_parent(parent)
     {
         m_option.readOptionSetting(m_parent);
     }
 
     ~BrushWriter() {
         m_option.writeOptionSetting(m_parent);
     }
 
     KisBrushSP brush() {
         return m_option.brush();
     }
 
     KisBrushBasedPaintOpSettings *m_parent;
     KisBrushOption m_option;
 };
 
 
 KisBrushBasedPaintOpSettings::KisBrushBasedPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
             KisCurrentOutlineFetcher::ROTATION_OPTION |
             KisCurrentOutlineFetcher::MIRROR_OPTION)
 {
 }
 
 bool KisBrushBasedPaintOpSettings::paintIncremental()
 {
     if (hasProperty("PaintOpAction")) {
         return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
     }
     return true;
 }
 
 bool KisBrushBasedPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED);
 }
 
 
 int KisBrushBasedPaintOpSettings::rate() const
 {
     return getInt(AIRBRUSH_RATE);
 }
 
 KisPaintOpSettingsSP KisBrushBasedPaintOpSettings::clone() const
 {
     KisPaintOpSettingsSP _settings = KisOutlineGenerationPolicy<KisPaintOpSettings>::clone();
     KisBrushBasedPaintOpSettingsSP settings = dynamic_cast<KisBrushBasedPaintOpSettings*>(_settings.data());
     settings->m_savedBrush = this->brush();
     return settings;
 }
 
 KisBrushSP KisBrushBasedPaintOpSettings::brush() const
 {
     KisBrushSP brush = m_savedBrush;
 
     if (!brush) {
         BrushReader w(this);
         brush = w.brush();
         m_savedBrush = brush;
     }
 
     return brush;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutlineImpl(const KisPaintInformation &info,
                                                             OutlineMode mode,
                                                             qreal additionalScale,
                                                             bool forceOutline)
 {
     QPainterPath path;
 
     if (forceOutline || mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         KisBrushSP brush = this->brush();
         if (!brush) return path;
         qreal finalScale = brush->scale() * additionalScale;
 
         QPainterPath realOutline = brush->outline();
 
         if (mode == CursorIsCircleOutline || mode == CursorTiltOutline ||
             (forceOutline && mode == CursorNoOutline)) {
 
             QPainterPath ellipse;
             ellipse.addEllipse(realOutline.boundingRect());
             realOutline = ellipse;
         }
 
         path = outlineFetcher()->fetchOutline(info, this, realOutline, finalScale, brush->angle());
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine = makeTiltIndicator(info,
                 realOutline.boundingRect().center(),
                 realOutline.boundingRect().width() * 0.5,
                 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, finalScale, 0.0, true, realOutline.boundingRect().center().x(), realOutline.boundingRect().center().y()));
         }
     }
 
     return path;
 }
 
 QPainterPath KisBrushBasedPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     return brushOutlineImpl(info, mode, 1.0);
 }
 
 bool KisBrushBasedPaintOpSettings::isValid() const
 {
     QString filename = getString("requiredBrushFile", QString());
     if (!filename.isEmpty()) {
         KisBrushSP brush = KisBrushServer::instance()->brushServer()->resourceByFilename(filename);
         if (!brush) {
             return false;
         }
     }
     return true;
 }
 
 bool KisBrushBasedPaintOpSettings::isLoadable()
 {
     return (KisBrushServer::instance()->brushServer()->resources().count() > 0);
 }
 
 void KisBrushBasedPaintOpSettings::setAngle(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAngle(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::angle()
 {
     return this->brush()->angle();
 }
 
 void KisBrushBasedPaintOpSettings::setSpacing(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setSpacing(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::spacing()
 {
     return this->brush()->spacing();
 }
 
 void KisBrushBasedPaintOpSettings::setAutoSpacing(bool active, qreal coeff)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
     w.brush()->setAutoSpacing(active, coeff);
 }
 
 
 bool KisBrushBasedPaintOpSettings::autoSpacingActive()
 {
     return this->brush()->autoSpacingActive();
 }
 
 qreal KisBrushBasedPaintOpSettings::autoSpacingCoeff()
 {
     return this->brush()->autoSpacingCoeff();
 }
 
 void KisBrushBasedPaintOpSettings::setPaintOpSize(qreal value)
 {
     BrushWriter w(this);
     if (!w.brush()) return;
 
     w.brush()->setUserEffectiveSize(value);
 }
 
 qreal KisBrushBasedPaintOpSettings::paintOpSize() const
 {
     return this->brush()->userEffectiveSize();
 }
 
 
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 
 QList<KisUniformPaintOpPropertySP> KisBrushBasedPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "angle",
                     "Angle",
                     settings, 0);
 
             prop->setRange(0, 360);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal angleResult = kisRadiansToDegrees(s->angle());
                     prop->setValue(angleResult);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAngle(kisDegreesToRadians(prop->value().toReal()));
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisUniformPaintOpPropertyCallback *prop =
                 new KisUniformPaintOpPropertyCallback(
                     KisUniformPaintOpPropertyCallback::Bool,
                     "auto_spacing",
                     "Auto Spacing",
                     settings, 0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     prop->setValue(s->autoSpacingActive());
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     s->setAutoSpacing(prop->value().toBool(), s->autoSpacingCoeff());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
 
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     "Spacing",
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
+            prop->setExponentRatio(3.0);
+
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     const qreal value = s->autoSpacingActive() ?
                         s->autoSpacingCoeff() : s->spacing();
                     prop->setValue(value);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisBrushBasedPaintOpSettings *s =
                         dynamic_cast<KisBrushBasedPaintOpSettings*>(prop->settings().data());
 
                     if (s->autoSpacingActive()) {
                         s->setAutoSpacing(true, prop->value().toReal());
                     } else {
                         s->setSpacing(prop->value().toReal());
                     }
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
 
     return KisPaintOpSettings::uniformProperties(settings) + props;
 }
 
 void KisBrushBasedPaintOpSettings::onPropertyChanged()
 {
     m_savedBrush.clear();
     KisOutlineGenerationPolicy<KisPaintOpSettings>::onPropertyChanged();
 }
diff --git a/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp b/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
index 3d486c6cf7..2a2b8572eb 100644
--- a/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
+++ b/plugins/paintops/libpaintop/kis_spacing_selection_widget.cpp
@@ -1,129 +1,130 @@
 /*
  *  Copyright (c) 2014 Dmitry Kazakov <dimula73@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_spacing_selection_widget.h"
 
 #include <QCheckBox>
 #include <QHBoxLayout>
 
 #include "klocalizedstring.h"
 
 #include "kis_signals_blocker.h"
 #include "kis_slider_spin_box.h"
 
 
 
 struct KisSpacingSelectionWidget::Private
 {
     Private(KisSpacingSelectionWidget *_q)
         : q(_q), oldSliderValue(0.1)
     {
     }
 
     KisSpacingSelectionWidget *q;
 
     KisDoubleSliderSpinBox *slider;
     QCheckBox *autoButton;
 
     qreal oldSliderValue;
 
     void slotSpacingChanged(qreal value);
     void slotAutoSpacing(bool value);
 };
 
 
 KisSpacingSelectionWidget::KisSpacingSelectionWidget(QWidget *parent)
     : QWidget(parent),
       m_d(new Private(this))
 {
     m_d->slider = new KisDoubleSliderSpinBox(this);
-    m_d->slider->setRange(0.0, 10.0, 2);
-    m_d->slider->setSingleStep(0.01);
+    m_d->slider->setRange(0.01, 10.0, 2);
+    m_d->slider->setExponentRatio(3);
+    m_d->slider->setSingleStep(0.1);
     m_d->slider->setValue(0.1);
     m_d->slider->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
 
 
     m_d->autoButton = new QCheckBox(this);
     m_d->autoButton->setText(i18nc("@action:button", "Auto"));
     m_d->autoButton->setToolTip(i18nc("@info:tooltip", "In auto mode the spacing of the brush will be calculated automatically depending on its size"));
     m_d->autoButton->setCheckable(true);
     m_d->autoButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
 
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->addWidget(m_d->autoButton);
     layout->addWidget(m_d->slider);
     layout->setMargin(0);
 
     connect(m_d->slider, SIGNAL(valueChanged(qreal)), SLOT(slotSpacingChanged(qreal)));
     connect(m_d->autoButton, SIGNAL(toggled(bool)), SLOT(slotAutoSpacing(bool)));
 }
 
 KisSpacingSelectionWidget::~KisSpacingSelectionWidget()
 {
 }
 
 qreal KisSpacingSelectionWidget::spacing() const
 {
     return autoSpacingActive() ? 0.1 : m_d->slider->value();
 }
 
 bool KisSpacingSelectionWidget::autoSpacingActive() const
 {
     return m_d->autoButton->isChecked();
 }
 
 qreal KisSpacingSelectionWidget::autoSpacingCoeff() const
 {
     return autoSpacingActive() ? m_d->slider->value() : 1.0;
 }
 
 void KisSpacingSelectionWidget::setSpacing(bool isAuto, qreal spacing)
 {
     KisSignalsBlocker b1(m_d->autoButton);
     KisSignalsBlocker b2(m_d->slider);
 
     m_d->autoButton->setChecked(isAuto);
     m_d->slider->setValue(spacing);
 }
 
 void KisSpacingSelectionWidget::Private::slotSpacingChanged(qreal value)
 {
     Q_UNUSED(value);
     emit q->sigSpacingChanged();
 }
 
 void KisSpacingSelectionWidget::Private::slotAutoSpacing(bool value)
 {
     qreal newSliderValue = 0.0;
 
     if (value) {
         newSliderValue = 1.0;
         oldSliderValue = slider->value();
     } else {
         newSliderValue = oldSliderValue;
     }
 
     {
         KisSignalsBlocker b(slider);
         slider->setValue(newSliderValue);
     }
 
     emit q->sigSpacingChanged();
 }
 
 #include "moc_kis_spacing_selection_widget.moc"
diff --git a/plugins/paintops/spray/kis_spray_paintop_settings.cpp b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
index 6138ede053..154562824b 100644
--- a/plugins/paintops/spray/kis_spray_paintop_settings.cpp
+++ b/plugins/paintops/spray/kis_spray_paintop_settings.cpp
@@ -1,238 +1,239 @@
 /*
  *  Copyright (c) 2008,2009,2010 Lukáš Tvrdý <lukast.dev@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include <cmath>
 
 #include <kis_paint_action_type_option.h>
 #include <kis_color_option.h>
 
 #include "kis_spray_paintop_settings.h"
 #include "kis_sprayop_option.h"
 #include "kis_spray_shape_option.h"
 #include <kis_airbrush_option.h>
 
 struct KisSprayPaintOpSettings::Private
 {
     QList<KisUniformPaintOpPropertyWSP> uniformProperties;
 };
 
 
 KisSprayPaintOpSettings::KisSprayPaintOpSettings()
     : KisOutlineGenerationPolicy<KisPaintOpSettings>(KisCurrentOutlineFetcher::SIZE_OPTION |
                                                      KisCurrentOutlineFetcher::ROTATION_OPTION),
     m_d(new Private)
 {
 }
 
 KisSprayPaintOpSettings::~KisSprayPaintOpSettings()
 {
 }
 
 void KisSprayPaintOpSettings::setPaintOpSize(qreal value)
 {
     KisSprayProperties option;
     option.readOptionSetting(this);
     option.diameter = value;
     option.writeOptionSetting(this);
 }
 
 qreal KisSprayPaintOpSettings::paintOpSize() const
 {
 
     KisSprayProperties option;
     option.readOptionSetting(this);
 
     return option.diameter;
 }
 
 bool KisSprayPaintOpSettings::paintIncremental()
 {
     return (enumPaintActionType)getInt("PaintOpAction", WASH) == BUILDUP;
 }
 
 bool KisSprayPaintOpSettings::isAirbrushing() const
 {
     return getBool(AIRBRUSH_ENABLED);
 }
 
 int KisSprayPaintOpSettings::rate() const
 {
     return getInt(AIRBRUSH_RATE);
 }
 
 
 QPainterPath KisSprayPaintOpSettings::brushOutline(const KisPaintInformation &info, OutlineMode mode)
 {
     QPainterPath path;
     if (mode == CursorIsOutline || mode == CursorIsCircleOutline || mode == CursorTiltOutline) {
         qreal width = getInt(SPRAY_DIAMETER);
         qreal height = getInt(SPRAY_DIAMETER) * getDouble(SPRAY_ASPECT);
         path = ellipseOutline(width, height, getDouble(SPRAY_SCALE), getDouble(SPRAY_ROTATION));
 
         QPainterPath tiltLine;
         QLineF tiltAngle(QPointF(0.0,0.0), QPointF(0.0,width));
         tiltAngle.setLength(qMax(width*0.5, 50.0) * (1 - info.tiltElevation(info, 60.0, 60.0, true)));
         tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))-3.0);
         tiltLine.moveTo(tiltAngle.p1());
         tiltLine.lineTo(tiltAngle.p2());
         tiltAngle.setAngle((360.0 - fmod(KisPaintInformation::tiltDirection(info, true) * 360.0 + 270.0, 360.0))+3.0);
         tiltLine.lineTo(tiltAngle.p2());
         tiltLine.lineTo(tiltAngle.p1());
 
         path = outlineFetcher()->fetchOutline(info, this, path);
 
         if (mode == CursorTiltOutline) {
             QPainterPath tiltLine =
                 makeTiltIndicator(info, QPointF(0.0, 0.0), width * 0.5, 3.0);
             path.addPath(outlineFetcher()->fetchOutline(info, this, tiltLine, 1.0, 0.0, true, 0, 0));
         }
     }
     return path;
 }
 
 #include <brushengine/kis_slider_based_paintop_property.h>
 #include "kis_paintop_preset.h"
 #include "kis_paintop_settings_update_proxy.h"
 #include "kis_standard_uniform_properties_factory.h"
 
 
 QList<KisUniformPaintOpPropertySP> KisSprayPaintOpSettings::uniformProperties(KisPaintOpSettingsSP settings)
 {
     QList<KisUniformPaintOpPropertySP> props =
         listWeakToStrong(m_d->uniformProperties);
 
     if (props.isEmpty()) {
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spacing",
                     i18n("Spacing"),
                     settings, 0);
 
             prop->setRange(0.01, 10);
             prop->setSingleStep(0.01);
+            prop->setExponentRatio(3.0);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(option.spacing);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.spacing = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisIntSliderBasedPaintOpPropertyCallback *prop =
                 new KisIntSliderBasedPaintOpPropertyCallback(
                     KisIntSliderBasedPaintOpPropertyCallback::Int,
                     "spray_particlecount",
                     i18n("Particle Count"),
                     settings, 0);
 
             prop->setRange(0, 1000);
             prop->setExponentRatio(3);
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
 
                     prop->setValue(int(option.particleCount));
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.particleCount = prop->value().toInt();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return !option.useDensity;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
         {
             KisDoubleSliderBasedPaintOpPropertyCallback *prop =
                 new KisDoubleSliderBasedPaintOpPropertyCallback(
                     KisDoubleSliderBasedPaintOpPropertyCallback::Double,
                     "spray_density",
                     i18n("Density"),
                     settings, 0);
 
             prop->setRange(0.1, 100);
             prop->setSingleStep(0.01);
             prop->setDecimals(2);
             prop->setExponentRatio(3);
             prop->setSuffix(i18n("%"));
 
             prop->setReadCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     prop->setValue(option.coverage);
                 });
             prop->setWriteCallback(
                 [](KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     option.coverage = prop->value().toReal();
                     option.writeOptionSetting(prop->settings().data());
                 });
             prop->setIsVisibleCallback(
                 [](const KisUniformPaintOpProperty *prop) {
                     KisSprayProperties option;
                     option.readOptionSetting(prop->settings().data());
                     return option.useDensity;
                 });
 
             QObject::connect(preset()->updateProxy(), SIGNAL(sigSettingsChanged()), prop, SLOT(requestReadValue()));
             prop->requestReadValue();
             props << toQShared(prop);
         }
     }
     {
         using namespace KisStandardUniformPropertiesFactory;
 
         Q_FOREACH (KisUniformPaintOpPropertySP prop, KisPaintOpSettings::uniformProperties(settings)) {
             if (prop->id() == opacity.id() ||
                 prop->id() == size.id()) {
 
                 props.prepend(prop);
             }
         }
     }
 
     return props;
 }