diff --git a/plugins/paintops/sketch/CMakeLists.txt b/plugins/paintops/sketch/CMakeLists.txt
index a2a8e5c5da7..60947149b39 100644
--- a/plugins/paintops/sketch/CMakeLists.txt
+++ b/plugins/paintops/sketch/CMakeLists.txt
@@ -1,12 +1,11 @@
 set(kritasketchpaintop_SOURCES
     sketch_paintop_plugin.cpp
     kis_sketch_paintop.cpp
-    kis_sketchop_option.cpp
-    kis_density_option.cpp
-    kis_linewidth_option.cpp
-    kis_offset_scale_option.cpp
     kis_sketch_paintop_settings.cpp
     kis_sketch_paintop_settings_widget.cpp
+    KisSketchOpOptionData.cpp
+    KisSketchOpOptionModel.cpp
+    KisSketchOpOptionWidget.cpp
     )
 
 ki18n_wrap_ui(kritasketchpaintop_SOURCES wdgsketchoptions.ui )
diff --git a/plugins/paintops/sketch/KisSketchOpOptionData.cpp b/plugins/paintops/sketch/KisSketchOpOptionData.cpp
new file mode 100644
index 00000000000..05e12662d09
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionData.cpp
@@ -0,0 +1,62 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#include "KisSketchOpOptionData.h"
+
+#include "kis_properties_configuration.h"
+#include <kis_paintop_lod_limitations.h>
+
+
+const QString SKETCH_PROBABILITY = "Sketch/probability";
+const QString SKETCH_DISTANCE_DENSITY = "Sketch/distanceDensity";
+const QString SKETCH_OFFSET = "Sketch/offset";
+const QString SKETCH_USE_SIMPLE_MODE = "Sketch/simpleMode";
+const QString SKETCH_MAKE_CONNECTION = "Sketch/makeConnection";
+const QString SKETCH_MAGNETIFY = "Sketch/magnetify";
+const QString SKETCH_LINE_WIDTH = "Sketch/lineWidth";
+const QString SKETCH_RANDOM_RGB = "Sketch/randomRGB";
+const QString SKETCH_RANDOM_OPACITY = "Sketch/randomOpacity";
+const QString SKETCH_DISTANCE_OPACITY = "Sketch/distanceOpacity";
+const QString SKETCH_ANTIALIASING = "Sketch/antiAliasing";
+
+
+bool KisSketchOpOptionData::read(const KisPropertiesConfiguration *setting)
+{
+    probability = setting->getDouble(SKETCH_PROBABILITY, 0.50);
+    offset = setting->getDouble(SKETCH_OFFSET, 30.0);
+    lineWidth = setting->getInt(SKETCH_LINE_WIDTH, 1);
+    simpleMode = setting->getBool(SKETCH_USE_SIMPLE_MODE, false);
+    makeConnection = setting->getBool(SKETCH_MAKE_CONNECTION, true);
+    magnetify = setting->getBool(SKETCH_MAGNETIFY, true);
+    randomRGB = setting->getBool(SKETCH_RANDOM_RGB, false);
+    randomOpacity = setting->getBool(SKETCH_RANDOM_OPACITY, false);
+    distanceDensity = setting->getBool(SKETCH_DISTANCE_DENSITY, true);
+    distanceOpacity = setting->getBool(SKETCH_DISTANCE_OPACITY, false);
+    antiAliasing = setting->getBool(SKETCH_ANTIALIASING, false);
+
+    return true;
+}
+
+void KisSketchOpOptionData::write(KisPropertiesConfiguration *setting) const
+{
+    setting->setProperty(SKETCH_PROBABILITY, probability);
+    setting->setProperty(SKETCH_OFFSET, offset);
+    setting->setProperty(SKETCH_LINE_WIDTH, lineWidth);
+    setting->setProperty(SKETCH_USE_SIMPLE_MODE, simpleMode);
+    setting->setProperty(SKETCH_MAKE_CONNECTION, makeConnection);
+    setting->setProperty(SKETCH_MAGNETIFY, magnetify);
+    setting->setProperty(SKETCH_RANDOM_RGB, randomRGB);
+    setting->setProperty(SKETCH_RANDOM_OPACITY, randomOpacity);
+    setting->setProperty(SKETCH_DISTANCE_DENSITY, distanceDensity);
+    setting->setProperty(SKETCH_DISTANCE_OPACITY, distanceOpacity);
+    setting->setProperty(SKETCH_ANTIALIASING, antiAliasing);
+}
+
+KisPaintopLodLimitations KisSketchOpOptionData::lodLimitations() const
+{
+    KisPaintopLodLimitations l;
+    l.limitations << KoID("sketch-brush", i18nc("PaintOp instant preview limitation", "Sketch brush (differences in connecting lines are possible)"));
+    return l;
+}
diff --git a/plugins/paintops/sketch/KisSketchOpOptionData.h b/plugins/paintops/sketch/KisSketchOpOptionData.h
new file mode 100644
index 00000000000..e1d5eca3409
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionData.h
@@ -0,0 +1,50 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#ifndef KIS_SKETCHOP_OPTION_DATA_H
+#define KIS_SKETCHOP_OPTION_DATA_H
+
+
+#include "kis_types.h"
+#include <boost/operators.hpp>
+
+class KisPropertiesConfiguration;
+class KisPaintopLodLimitations;
+
+struct KisSketchOpOptionData : boost::equality_comparable<KisSketchOpOptionData>
+{
+    inline friend bool operator==(const KisSketchOpOptionData &lhs, const KisSketchOpOptionData &rhs) {
+        return qFuzzyCompare(lhs.offset, rhs.offset)
+            && qFuzzyCompare(lhs.probability, rhs.probability)
+            && lhs.simpleMode == rhs.simpleMode
+            && lhs.makeConnection == rhs.makeConnection
+            && lhs.magnetify == rhs.magnetify
+            && lhs.randomRGB == rhs.randomRGB
+            && lhs.randomOpacity == rhs.randomOpacity
+            && lhs.distanceOpacity == rhs.distanceOpacity
+            && lhs.distanceDensity == rhs.distanceDensity
+            && lhs.antiAliasing == rhs.antiAliasing
+            && lhs.lineWidth == rhs.lineWidth;
+    }
+
+    qreal offset {30.0}; // perc
+    qreal probability {50.0}; // perc
+    bool simpleMode {false};
+    bool makeConnection {true};
+    bool magnetify {true};
+    bool randomRGB {false};
+    bool randomOpacity {false};
+    bool distanceOpacity {false};
+    bool distanceDensity {true};
+    bool antiAliasing {false};
+    int lineWidth {1}; // px
+
+    bool read(const KisPropertiesConfiguration *setting);
+    void write(KisPropertiesConfiguration *setting) const;
+
+    KisPaintopLodLimitations lodLimitations() const;
+};
+
+#endif // KIS_SKETCHOP_OPTION_DATA_H
diff --git a/plugins/paintops/sketch/KisSketchOpOptionModel.cpp b/plugins/paintops/sketch/KisSketchOpOptionModel.cpp
new file mode 100644
index 00000000000..4ab0d742ef2
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionModel.cpp
@@ -0,0 +1,27 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#include "KisSketchOpOptionModel.h"
+
+#include <KisZug.h>
+
+using namespace KisWidgetConnectionUtils;
+
+KisSketchOpOptionModel::KisSketchOpOptionModel(lager::cursor<KisSketchOpOptionData> _optionData)
+    : optionData(_optionData)
+    , LAGER_QT(offset) {_optionData[&KisSketchOpOptionData::offset]}
+    , LAGER_QT(probability) {_optionData[&KisSketchOpOptionData::probability]
+                .zoom(kiszug::lenses::scale<qreal>(100.0))}
+    , LAGER_QT(simpleMode) {_optionData[&KisSketchOpOptionData::simpleMode]}
+    , LAGER_QT(makeConnection) {_optionData[&KisSketchOpOptionData::makeConnection]}
+    , LAGER_QT(magnetify) {_optionData[&KisSketchOpOptionData::magnetify]}
+    , LAGER_QT(randomRGB) {_optionData[&KisSketchOpOptionData::randomRGB]}
+    , LAGER_QT(randomOpacity) {_optionData[&KisSketchOpOptionData::randomOpacity]}
+    , LAGER_QT(distanceOpacity) {_optionData[&KisSketchOpOptionData::distanceOpacity]}
+    , LAGER_QT(distanceDensity) {_optionData[&KisSketchOpOptionData::distanceDensity]}
+    , LAGER_QT(antiAliasing) {_optionData[&KisSketchOpOptionData::antiAliasing]}
+    , LAGER_QT(lineWidth) {_optionData[&KisSketchOpOptionData::lineWidth]}
+{
+}
diff --git a/plugins/paintops/sketch/KisSketchOpOptionModel.h b/plugins/paintops/sketch/KisSketchOpOptionModel.h
new file mode 100644
index 00000000000..efee4fa767b
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionModel.h
@@ -0,0 +1,36 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#ifndef KIS_SKETCHOP_OPTION_MODEL_H
+#define KIS_SKETCHOP_OPTION_MODEL_H
+
+#include <lager/cursor.hpp>
+#include <lager/extra/qt.hpp>
+
+#include "KisSketchOpOptionData.h"
+#include "KisWidgetConnectionUtils.h"
+
+class KisSketchOpOptionModel : public QObject
+{
+    Q_OBJECT
+public:
+    KisSketchOpOptionModel(lager::cursor<KisSketchOpOptionData> optionData);
+
+    lager::cursor<KisSketchOpOptionData> optionData;
+
+    LAGER_QT_CURSOR(qreal, offset);
+    LAGER_QT_CURSOR(qreal, probability);
+    LAGER_QT_CURSOR(bool, simpleMode);
+    LAGER_QT_CURSOR(bool, makeConnection);
+    LAGER_QT_CURSOR(bool, magnetify);
+    LAGER_QT_CURSOR(bool, randomRGB);
+    LAGER_QT_CURSOR(bool, randomOpacity);
+    LAGER_QT_CURSOR(bool, distanceOpacity);
+    LAGER_QT_CURSOR(bool, distanceDensity);
+    LAGER_QT_CURSOR(bool, antiAliasing);
+    LAGER_QT_CURSOR(int, lineWidth);
+};
+
+#endif // KIS_SKETCHOP_OPTION_MODEL_H
diff --git a/plugins/paintops/sketch/KisSketchOpOptionWidget.cpp b/plugins/paintops/sketch/KisSketchOpOptionWidget.cpp
new file mode 100644
index 00000000000..894a6c5b892
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionWidget.cpp
@@ -0,0 +1,100 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#include "KisSketchOpOptionWidget.h"
+
+#include <lager/constant.hpp>
+#include "ui_wdgsketchoptions.h"
+
+#include "KisSketchOpOptionModel.h"
+#include <kis_paintop_lod_limitations.h>
+
+namespace {
+
+
+class KisSketchOpWidget: public QWidget, public Ui::WdgSketchOptions
+{
+public:
+    KisSketchOpWidget(QWidget *parent = 0)
+        : QWidget(parent) {
+        setupUi(this);
+
+        lineWidthSPBox->setRange(1, 100, 0);
+        lineWidthSPBox->setSuffix(i18n(" px"));
+        lineWidthSPBox->setExponentRatio(1.5);
+
+        offsetSPBox->setRange(0.0, 200.0, 0);
+        offsetSPBox->setSuffix(i18n("%"));
+
+        densitySPBox->setRange(0.0, 100.0, 0);
+        densitySPBox->setSuffix(i18n("%"));
+    }
+};
+
+
+}
+
+
+struct KisSketchOpOptionWidget::Private
+{
+    Private(lager::cursor<KisSketchOpOptionData> optionData)
+        : model(optionData)
+    {
+    }
+
+    KisSketchOpOptionModel model;
+};
+
+
+KisSketchOpOptionWidget::KisSketchOpOptionWidget(lager::cursor<KisSketchOpOptionData> optionData)
+    : KisPaintOpOption(i18n("Brush size"), KisPaintOpOption::GENERAL, true)
+    , m_d(new Private(optionData))
+{
+
+	KisSketchOpWidget *widget = new KisSketchOpWidget();
+	setObjectName("KisSketchOpOption");
+
+	m_checkable = false;
+
+    using namespace KisWidgetConnectionUtils;
+
+    connectControl(widget->offsetSPBox, &m_d->model, "offset");
+    connectControl(widget->lineWidthSPBox, &m_d->model, "lineWidth");
+    connectControl(widget->densitySPBox, &m_d->model, "probability");
+    connectControl(widget->simpleModeCHBox, &m_d->model, "simpleMode");
+    connectControl(widget->connectionCHBox, &m_d->model, "makeConnection");
+    connectControl(widget->magnetifyCHBox, &m_d->model, "magnetify");
+    connectControl(widget->randomRGBCHbox, &m_d->model, "randomRGB");
+    connectControl(widget->randomOpacityCHbox, &m_d->model, "randomOpacity");
+    connectControl(widget->distanceDensityCHBox, &m_d->model, "distanceDensity");
+    connectControl(widget->distanceOpacityCHbox, &m_d->model, "distanceOpacity");
+    connectControl(widget->antiAliasingCHBox, &m_d->model, "antiAliasing");
+
+    m_d->model.optionData.bind(std::bind(&KisSketchOpOptionWidget::emitSettingChanged, this));
+
+    setConfigurationPage(widget);
+}
+
+KisSketchOpOptionWidget::~KisSketchOpOptionWidget()
+{
+}
+
+void KisSketchOpOptionWidget::writeOptionSetting(KisPropertiesConfigurationSP setting) const
+{
+    KisSketchOpOptionData data = *m_d->model.optionData;
+    data.write(setting.data());
+}
+
+void KisSketchOpOptionWidget::readOptionSetting(const KisPropertiesConfigurationSP setting)
+{
+    KisSketchOpOptionData data = *m_d->model.optionData;
+    data.read(setting.data());
+    m_d->model.optionData.set(data);
+}
+
+lager::reader<KisPaintopLodLimitations> KisSketchOpOptionWidget::lodLimitationsReader() const
+{
+    return m_d->model.optionData.map(&KisSketchOpOptionData::lodLimitations);
+}
diff --git a/plugins/paintops/sketch/KisSketchOpOptionWidget.h b/plugins/paintops/sketch/KisSketchOpOptionWidget.h
new file mode 100644
index 00000000000..f44e1da83e8
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchOpOptionWidget.h
@@ -0,0 +1,34 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#ifndef KIS_SKETCHOP_OPTION_WIDGET_H
+#define KIS_SKETCHOP_OPTION_WIDGET_H
+
+#include <kis_paintop_option.h>
+#include <KisSketchOpOptionData.h>
+#include <lager/cursor.hpp>
+
+struct KisSketchOpOptionData;
+
+class KisSketchOpOptionWidget : public KisPaintOpOption
+{
+public:
+    using data_type = KisSketchOpOptionData;
+
+    KisSketchOpOptionWidget(lager::cursor<KisSketchOpOptionData> optionData);
+    ~KisSketchOpOptionWidget();
+
+    void writeOptionSetting(KisPropertiesConfigurationSP setting) const override;
+    void readOptionSetting(const KisPropertiesConfigurationSP setting) override;
+
+protected:
+    lager::reader<KisPaintopLodLimitations> lodLimitationsReader() const override;
+
+private:
+    struct Private;
+    const QScopedPointer<Private> m_d;
+};
+
+#endif // KIS_SKETCHOP_OPTION_WIDGET_H
diff --git a/plugins/paintops/sketch/KisSketchStandardOptionData.h b/plugins/paintops/sketch/KisSketchStandardOptionData.h
new file mode 100644
index 00000000000..f03c6a1051a
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchStandardOptionData.h
@@ -0,0 +1,41 @@
+/*
+ *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#ifndef KISSKETCHSTANDARDOPTIONDATA_H
+#define KISSKETCHSTANDARDOPTIONDATA_H
+
+#include <KisCurveOptionData.h>
+
+struct KisOffsetScaleOptionData : KisCurveOptionData
+{
+    KisOffsetScaleOptionData()
+        : KisCurveOptionData(
+              KoID("Offset scale", i18n("Offset scale")),
+              true, false, false,
+              0.0, 1.0)
+    {}
+};
+
+struct KisLineWidthOptionData : KisCurveOptionData
+{
+    KisLineWidthOptionData()
+        : KisCurveOptionData(
+              KoID("Line width", i18n("Line width")),
+              true, false, false,
+              0.0, 1.0)
+    {}
+};
+
+struct KisDensityOptionData : KisCurveOptionData
+{
+    KisDensityOptionData()
+        : KisCurveOptionData(
+              KoID("Density", i18n("Density")),
+              true, false, false,
+              0.0, 1.0)
+    {}
+};
+
+#endif // KISSKETCHSTANDARDOPTIONDATA_H
diff --git a/plugins/paintops/sketch/KisSketchStandardOptions.h b/plugins/paintops/sketch/KisSketchStandardOptions.h
new file mode 100644
index 00000000000..9e88e6e4558
--- /dev/null
+++ b/plugins/paintops/sketch/KisSketchStandardOptions.h
@@ -0,0 +1,16 @@
+/*
+ *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#ifndef KISSKETCHSTANDARDOPTIONS_H
+#define KISSKETCHSTANDARDOPTIONS_H
+
+#include <KisSketchStandardOptionData.h>
+#include <KisStandardOptions.h>
+
+using KisOffsetScaleOption = KisStandardOption<KisOffsetScaleOptionData>;
+using KisLineWidthOption = KisStandardOption<KisLineWidthOptionData>;
+using KisDensityOption = KisStandardOption<KisDensityOptionData>;
+
+#endif // KISSKETCHSTANDARDOPTIONS_H
diff --git a/plugins/paintops/sketch/kis_density_option.cpp b/plugins/paintops/sketch/kis_density_option.cpp
deleted file mode 100644
index 7b5e2408c0e..00000000000
--- a/plugins/paintops/sketch/kis_density_option.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#include "kis_density_option.h"
-#include <klocalizedstring.h>
-
-KisDensityOption::KisDensityOption()
-    : KisCurveOption(KoID("Density", i18n("Density")), KisPaintOpOption::GENERAL, false)
-{
-}
-
-
-double KisDensityOption::apply(const KisPaintInformation & info, double probability) const
-{
-    if (!isChecked()) return probability;
-    return computeSizeLikeValue(info) * probability;
-}
diff --git a/plugins/paintops/sketch/kis_density_option.h b/plugins/paintops/sketch/kis_density_option.h
deleted file mode 100644
index 0b23d087415..00000000000
--- a/plugins/paintops/sketch/kis_density_option.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#ifndef KIS_DENSITY_OPTION_H_
-#define KIS_DENSITY_OPTION_H_
-
-#include "kis_curve_option.h"
-#include <brushengine/kis_paint_information.h>
-
-class KisDensityOption : public KisCurveOption
-{
-public:
-    KisDensityOption();
-    double apply(const KisPaintInformation & info, double probability) const;
-};
-
-#endif
diff --git a/plugins/paintops/sketch/kis_linewidth_option.cpp b/plugins/paintops/sketch/kis_linewidth_option.cpp
deleted file mode 100644
index d36e52e9318..00000000000
--- a/plugins/paintops/sketch/kis_linewidth_option.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#include "kis_linewidth_option.h"
-
-KisLineWidthOption::KisLineWidthOption()
-    : KisCurveOption(KoID("Line width", i18n("Line width")), KisPaintOpOption::GENERAL, false)
-{
-}
-
-
-double KisLineWidthOption::apply(const KisPaintInformation & info, double lineWidth) const
-{
-    if (!isChecked()) return lineWidth;
-    return computeSizeLikeValue(info) * lineWidth;
-}
diff --git a/plugins/paintops/sketch/kis_linewidth_option.h b/plugins/paintops/sketch/kis_linewidth_option.h
deleted file mode 100644
index 87edcaca7e7..00000000000
--- a/plugins/paintops/sketch/kis_linewidth_option.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#ifndef KIS_LINEWIDTH_OPTION_H_
-#define KIS_LINEWIDTH_OPTION_H_
-
-#include "kis_curve_option.h"
-#include <brushengine/kis_paint_information.h>
-
-class KisLineWidthOption : public KisCurveOption
-{
-public:
-    KisLineWidthOption();
-    double apply(const KisPaintInformation & info, double lineWidth) const;
-};
-
-#endif
diff --git a/plugins/paintops/sketch/kis_offset_scale_option.cpp b/plugins/paintops/sketch/kis_offset_scale_option.cpp
deleted file mode 100644
index 518ea1dd9f4..00000000000
--- a/plugins/paintops/sketch/kis_offset_scale_option.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#include "kis_offset_scale_option.h"
-#include <klocalizedstring.h>
-
-KisOffsetScaleOption::KisOffsetScaleOption()
-    : KisCurveOption(KoID("Offset scale", i18n("Offset scale")), KisPaintOpOption::GENERAL, false)
-{
-}
-
-
-double KisOffsetScaleOption::apply(const KisPaintInformation & info, double offsetScale) const
-{
-    if (!isChecked()) return offsetScale;
-    return computeSizeLikeValue(info) * offsetScale;
-}
diff --git a/plugins/paintops/sketch/kis_offset_scale_option.h b/plugins/paintops/sketch/kis_offset_scale_option.h
deleted file mode 100644
index db1405453cf..00000000000
--- a/plugins/paintops/sketch/kis_offset_scale_option.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#ifndef KIS_OFFSETSCALE_OPTION_H_
-#define KIS_OFFSETSCALE_OPTION_H_
-
-#include "kis_curve_option.h"
-#include <brushengine/kis_paint_information.h>
-
-class KisOffsetScaleOption : public KisCurveOption
-{
-public:
-    KisOffsetScaleOption();
-    double apply(const KisPaintInformation & info, double offsetScale) const;
-};
-
-#endif
diff --git a/plugins/paintops/sketch/kis_sketch_paintop.cpp b/plugins/paintops/sketch/kis_sketch_paintop.cpp
index 416edbf579d..aa7f349b1a5 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop.cpp
@@ -26,7 +26,6 @@
 #include <brushengine/kis_paint_information.h>
 #include <kis_fixed_paint_device.h>
 
-#include <kis_pressure_opacity_option.h>
 #include <kis_dab_cache.h>
 #include "kis_lod_transform.h"
 #include <KoResourceLoadResult.h>
@@ -54,29 +53,24 @@
 
 KisSketchPaintOp::KisSketchPaintOp(const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
     : KisPaintOp(painter)
+    , m_opacityOption(settings.data())
+    , m_sizeOption(settings.data())
+    , m_rotationOption(settings.data())
+    , m_rateOption(settings.data())
+    , m_densityOption(settings.data())
+    , m_lineWidthOption(settings.data())
+    , m_offsetScaleOption(settings.data())
 {
     Q_UNUSED(image);
     Q_UNUSED(node);
 
-    m_airbrushOption.readOptionSetting(settings);
-    m_opacityOption.readOptionSetting(settings);
-    m_sizeOption.readOptionSetting(settings);
-    m_rotationOption.readOptionSetting(settings);
-    m_rateOption.readOptionSetting(settings);
-    m_sketchProperties.readOptionSetting(settings);
+    m_airbrushOption.read(settings.data());
+    m_sketchProperties.read(settings.data());
     m_brushOption.readOptionSetting(settings, settings->resourcesInterface(), settings->canvasResourcesInterface());
-    m_densityOption.readOptionSetting(settings);
-    m_lineWidthOption.readOptionSetting(settings);
-    m_offsetScaleOption.readOptionSetting(settings);
 
     m_brush = m_brushOption.brush();
     m_dabCache = new KisDabCache(m_brush);
 
-    m_opacityOption.resetAllSensors();
-    m_sizeOption.resetAllSensors();
-    m_rotationOption.resetAllSensors();
-    m_rateOption.resetAllSensors();
-
     m_painter = 0;
     m_count = 0;
 }
@@ -163,11 +157,11 @@ void KisSketchPaintOp::doPaintLine(const KisPaintInformation &pi1, const KisPain
     const qreal scale = lodAdditionalScale * m_sizeOption.apply(pi2);
     if ((scale * m_brush->width()) <= 0.01 || (scale * m_brush->height()) <= 0.01) return;
 
-    const qreal currentLineWidth = qMax(0.9, lodAdditionalScale * m_lineWidthOption.apply(pi2, m_sketchProperties.lineWidth));
+    const qreal currentLineWidth = qMax(0.9, lodAdditionalScale * m_lineWidthOption.apply(pi2) * m_sketchProperties.lineWidth);
 
-    const qreal currentOffsetScale = m_offsetScaleOption.apply(pi2, m_sketchProperties.offset);
+    const qreal currentOffsetScale = m_offsetScaleOption.apply(pi2) * m_sketchProperties.offset * 0.01;
     const double rotation = m_rotationOption.apply(pi2);
-    const double currentProbability = m_densityOption.apply(pi2, m_sketchProperties.probability);
+    const double currentProbability = m_densityOption.apply(pi2) * m_sketchProperties.probability;
 
     // shaded: does not draw this line, chrome does, fur does
     if (m_sketchProperties.makeConnection) {
diff --git a/plugins/paintops/sketch/kis_sketch_paintop.h b/plugins/paintops/sketch/kis_sketch_paintop.h
index b2d18d0e964..97b169f6927 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop.h
+++ b/plugins/paintops/sketch/kis_sketch_paintop.h
@@ -10,18 +10,16 @@
 #include <brushengine/kis_paintop.h>
 #include <kis_types.h>
 
-#include "kis_density_option.h"
-#include "kis_sketchop_option.h"
+#include "KisSketchStandardOptions.h"
+#include "KisSketchOpOptionData.h"
 #include "kis_sketch_paintop_settings.h"
 
 #include "kis_painter.h"
-#include <kis_airbrush_option_widget.h>
-#include <kis_pressure_size_option.h>
 #include <kis_brush_option.h>
-#include <kis_pressure_rotation_option.h>
-#include <kis_pressure_rate_option.h>
-#include "kis_linewidth_option.h"
-#include "kis_offset_scale_option.h"
+#include <KisStandardOptions.h>
+#include "KisRotationOption.h"
+#include "KisOpacityOption.h"
+#include "KisAirbrushOptionData.h"
 
 class KisDabCache;
 
@@ -57,17 +55,17 @@ class KisSketchPaintOp : public KisPaintOp
     // simple mode
     qreal m_radius {1.0};
 
-    KisPressureOpacityOption m_opacityOption;
-    KisPressureSizeOption m_sizeOption;
-    KisPressureRotationOption m_rotationOption;
-    KisPressureRateOption m_rateOption;
+    KisOpacityOption m_opacityOption;
+    KisSizeOption m_sizeOption;
+    KisRotationOption m_rotationOption;
+    KisRateOption m_rateOption;
     KisDensityOption m_densityOption;
     KisLineWidthOption m_lineWidthOption;
     KisOffsetScaleOption m_offsetScaleOption;
-    KisAirbrushOptionProperties m_airbrushOption;
+    KisAirbrushOptionData m_airbrushOption;
 
     KisBrushOptionProperties m_brushOption;
-    SketchProperties m_sketchProperties;
+    KisSketchOpOptionData m_sketchProperties;
 
     QVector<QPointF> m_points;
     int m_count {0};
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp b/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
index 6b62ea2d7e5..18e8239497b 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings.cpp
@@ -6,8 +6,6 @@
 
 #include "kis_sketch_paintop_settings.h"
 
-#include <kis_sketchop_option.h>
-
 #include <KisPaintingModeOptionData.h>
 #include "kis_current_outline_fetcher.h"
 #include <KisOptimizedBrushOutline.h>
@@ -26,7 +24,7 @@ bool KisSketchPaintOpSettings::paintIncremental()
 
 KisOptimizedBrushOutline KisSketchPaintOpSettings::brushOutline(const KisPaintInformation &info, const OutlineMode &mode, qreal alignForZoom)
 {
-    bool isSimpleMode = getBool(SKETCH_USE_SIMPLE_MODE);
+    bool isSimpleMode = getBool("Sketch/simpleMode");
 
     if (!isSimpleMode) {
         return KisBrushBasedPaintOpSettings::brushOutline(info, mode, alignForZoom);
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings.h b/plugins/paintops/sketch/kis_sketch_paintop_settings.h
index b90912c753d..a2c6445c670 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings.h
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings.h
@@ -12,8 +12,6 @@
 
 #include "kis_sketch_paintop_settings_widget.h"
 
-#include <kis_pressure_opacity_option.h>
-
 
 class KisSketchPaintOpSettings : public KisBrushBasedPaintOpSettings
 {
diff --git a/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp b/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
index 49f85924e47..c38077b8a24 100644
--- a/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
+++ b/plugins/paintops/sketch/kis_sketch_paintop_settings_widget.cpp
@@ -5,27 +5,19 @@
  */
 
 #include "kis_sketch_paintop_settings_widget.h"
-
-#include "kis_sketchop_option.h"
 #include "kis_sketch_paintop_settings.h"
 
 #include <kis_curve_option_widget.h>
-#include <kis_pressure_opacity_option.h>
 #include <kis_paintop_settings_widget.h>
-#include <KisPaintingModeOptionWidget.h>
-#include <KisPaintOpOptionWidgetUtils.h>
-#include <kis_pressure_size_option.h>
-#include <kis_pressure_rate_option.h>
-#include <KisAirbrushOptionWidget.h>
 #include <KisPaintOpOptionWidgetUtils.h>
 
-#include <QDomDocument>
-#include <QDomElement>
-#include <kis_pressure_rotation_option.h>
-#include "kis_density_option.h"
-#include "kis_linewidth_option.h"
-#include "kis_offset_scale_option.h"
+#include "KisSketchOpOptionWidget.h"
 #include <KisCompositeOpOptionWidget.h>
+#include <KisStandardOptionData.h>
+#include "KisSizeOptionWidget.h"
+#include "KisSketchStandardOptionData.h"
+#include <KisAirbrushOptionWidget.h>
+#include <KisPaintingModeOptionWidget.h>
 
 
 KisSketchPaintOpSettingsWidget::KisSketchPaintOpSettingsWidget(QWidget* parent)
@@ -33,32 +25,20 @@ KisSketchPaintOpSettingsWidget::KisSketchPaintOpSettingsWidget(QWidget* parent)
 {
     namespace kpowu = KisPaintOpOptionWidgetUtils;
 
-    addPaintOpOption(new KisSketchOpOption());
+    addPaintOpOption(kpowu::createOptionWidget<KisSketchOpOptionWidget>());
     addPaintOpOption(kpowu::createOptionWidget<KisCompositeOpOptionWidget>());
-    addPaintOpOption(new KisCurveOptionWidget(new KisPressureOpacityOption(), i18n("Transparent"), i18n("Opaque")));
-    addPaintOpOption(new KisCurveOptionWidget(new KisPressureSizeOption(), i18n("0%"), i18n("100%")));
-    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRotationOption(), i18n("-180°"), i18n("180°")));
-    addPaintOpOption(new KisCurveOptionWidget(new KisLineWidthOption(), i18n("0%"), i18n("100%")));
-    addPaintOpOption(new KisCurveOptionWidget(new KisOffsetScaleOption(), i18n("0%"), i18n("100%")));
-    addPaintOpOption(new KisCurveOptionWidget(new KisDensityOption(), i18n("0%"), i18n("100%")));
+    addPaintOpOption(kpowu::createOpacityOptionWidget());
+    addPaintOpOption(kpowu::createOptionWidget<KisSizeOptionWidget>());
+    addPaintOpOption(kpowu::createRotationOptionWidget());
+    addPaintOpOption(kpowu::createCurveOptionWidget(KisLineWidthOptionData(), KisPaintOpOption::GENERAL, i18n("0%"), i18n("100%")));
+    addPaintOpOption(kpowu::createCurveOptionWidget(KisOffsetScaleOptionData(), KisPaintOpOption::GENERAL, i18n("0%"), i18n("100%")));
+    addPaintOpOption(kpowu::createCurveOptionWidget(KisDensityOptionData(), KisPaintOpOption::GENERAL, i18n("0%"), i18n("100%")));
     addPaintOpOption(kpowu::createOptionWidget<KisAirbrushOptionWidget>(KisAirbrushOptionData(), false));
-    addPaintOpOption(new KisCurveOptionWidget(new KisPressureRateOption(), i18n("0%"), i18n("100%")));
+    addPaintOpOption(kpowu::createRateOptionWidget());
 
     KisPaintingModeOptionData defaultModeData;
     defaultModeData.paintingMode = enumPaintingMode::BUILDUP;
     addPaintOpOption(kpowu::createOptionWidget<KisPaintingModeOptionWidget>(defaultModeData));
-
-    KisPropertiesConfigurationSP reconfigurationCourier = configuration();
-    QDomDocument xMLAnalyzer;
-    xMLAnalyzer.setContent(reconfigurationCourier->getString("brush_definition"));
-
-    QDomElement firstTag = xMLAnalyzer.documentElement();
-    QDomElement firstTagsChild = firstTag.elementsByTagName("MaskGenerator").item(0).toElement();
-
-    firstTagsChild.attributeNode("diameter").setValue("128");
-
-    reconfigurationCourier->setProperty("brush_definition", xMLAnalyzer.toString());
-    setConfiguration(reconfigurationCourier);
 }
 
 KisSketchPaintOpSettingsWidget::~ KisSketchPaintOpSettingsWidget()
diff --git a/plugins/paintops/sketch/kis_sketchop_option.cpp b/plugins/paintops/sketch/kis_sketchop_option.cpp
deleted file mode 100644
index 07401875753..00000000000
--- a/plugins/paintops/sketch/kis_sketchop_option.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-#include "kis_sketchop_option.h"
-
-#include "ui_wdgsketchoptions.h"
-#include <brushengine/kis_paintop_lod_limitations.h>
-
-
-class KisSketchOpOptionsWidget: public QWidget, public Ui::WdgSketchOptions
-{
-public:
-    KisSketchOpOptionsWidget(QWidget *parent = 0)
-        : QWidget(parent) {
-        setupUi(this);
-    }
-};
-
-KisSketchOpOption::KisSketchOpOption()
-    : KisPaintOpOption(i18n("Brush size"), KisPaintOpOption::GENERAL, false)
-{
-    setObjectName("KisSketchOpOption");
-
-    m_checkable = false;
-    m_options = new KisSketchOpOptionsWidget();
-
-    // initialize slider values
-    m_options->lineWidthSPBox->setRange(1.0, 100.0, 0);
-    m_options->lineWidthSPBox->setValue(1.0);
-    m_options->lineWidthSPBox->setSuffix(i18n(" px"));
-    m_options->lineWidthSPBox->setExponentRatio(1.5);
-
-    m_options->offsetSPBox->setRange(0.0, 200.0, 0);
-    m_options->offsetSPBox->setValue(30.0);
-    m_options->offsetSPBox->setSuffix(i18n("%"));
-
-    m_options->densitySPBox->setRange(0.0, 100.0, 0);
-    m_options->densitySPBox->setValue(50.0);
-    m_options->densitySPBox->setSuffix(i18n("%"));
-
-
-    connect(m_options->offsetSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
-    connect(m_options->lineWidthSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
-    connect(m_options->densitySPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
-    connect(m_options->simpleModeCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->connectionCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->magnetifyCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->randomRGBCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->randomOpacityCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->distanceDensityCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->distanceOpacityCHbox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-    connect(m_options->antiAliasingCHBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
-
-    setConfigurationPage(m_options);
-}
-
-KisSketchOpOption::~KisSketchOpOption()
-{
-    // delete m_options;
-}
-
-void KisSketchOpOption::writeOptionSetting(KisPropertiesConfigurationSP settings) const
-{
-    settings->setProperty(SKETCH_OFFSET, m_options->offsetSPBox->value());
-    settings->setProperty(SKETCH_PROBABILITY, m_options->densitySPBox->value() * 0.01);
-    settings->setProperty(SKETCH_USE_SIMPLE_MODE, m_options->simpleModeCHBox->isChecked());
-    settings->setProperty(SKETCH_MAKE_CONNECTION, m_options->connectionCHBox->isChecked());
-    settings->setProperty(SKETCH_MAGNETIFY, m_options->magnetifyCHBox->isChecked());
-    settings->setProperty(SKETCH_RANDOM_RGB, m_options->randomRGBCHbox->isChecked());
-    settings->setProperty(SKETCH_LINE_WIDTH, m_options->lineWidthSPBox->value());
-    settings->setProperty(SKETCH_RANDOM_OPACITY, m_options->randomOpacityCHbox->isChecked());
-    settings->setProperty(SKETCH_DISTANCE_DENSITY, m_options->distanceDensityCHBox->isChecked());
-    settings->setProperty(SKETCH_DISTANCE_OPACITY, m_options->distanceOpacityCHbox->isChecked());
-    settings->setProperty(SKETCH_ANTIALIASING, m_options->antiAliasingCHBox->isChecked());
-}
-
-void KisSketchOpOption::readOptionSetting(const KisPropertiesConfigurationSP settings)
-{
-    m_options->offsetSPBox->setValue(settings->getDouble(SKETCH_OFFSET));
-    m_options->simpleModeCHBox->setChecked(settings->getBool(SKETCH_USE_SIMPLE_MODE));
-    m_options->connectionCHBox->setChecked(settings->getBool(SKETCH_MAKE_CONNECTION));
-    m_options->magnetifyCHBox->setChecked(settings->getBool(SKETCH_MAGNETIFY));
-    m_options->lineWidthSPBox->setValue(settings->getInt(SKETCH_LINE_WIDTH));
-    m_options->densitySPBox->setValue(settings->getDouble(SKETCH_PROBABILITY) * 100.0);
-    m_options->randomRGBCHbox->setChecked(settings->getBool(SKETCH_RANDOM_RGB));
-    m_options->randomOpacityCHbox->setChecked(settings->getBool(SKETCH_RANDOM_OPACITY));
-    m_options->distanceDensityCHBox->setChecked(settings->getBool(SKETCH_DISTANCE_DENSITY));
-    m_options->distanceOpacityCHbox->setChecked(settings->getBool(SKETCH_DISTANCE_OPACITY));
-    m_options->antiAliasingCHBox->setChecked(settings->getBool(SKETCH_ANTIALIASING));
-}
-
-void KisSketchOpOption::lodLimitations(KisPaintopLodLimitations *l) const
-{
-    l->limitations << KoID("sketch-brush", i18nc("PaintOp instant preview limitation", "Sketch brush (differences in connecting lines are possible)"));
-}
diff --git a/plugins/paintops/sketch/kis_sketchop_option.h b/plugins/paintops/sketch/kis_sketchop_option.h
deleted file mode 100644
index 829cdefc23f..00000000000
--- a/plugins/paintops/sketch/kis_sketchop_option.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <lukast.dev@gmail.com>
- *
- *  SPDX-License-Identifier: GPL-2.0-or-later
- */
-#ifndef KIS_SKETCHOP_OPTION_H
-#define KIS_SKETCHOP_OPTION_H
-
-#include <kis_paintop_option.h>
-
-const QString SKETCH_PROBABILITY = "Sketch/probability";
-const QString SKETCH_DISTANCE_DENSITY = "Sketch/distanceDensity";
-const QString SKETCH_OFFSET = "Sketch/offset";
-const QString SKETCH_USE_SIMPLE_MODE = "Sketch/simpleMode";
-const QString SKETCH_MAKE_CONNECTION = "Sketch/makeConnection";
-const QString SKETCH_MAGNETIFY = "Sketch/magnetify";
-const QString SKETCH_LINE_WIDTH = "Sketch/lineWidth";
-const QString SKETCH_RANDOM_RGB = "Sketch/randomRGB";
-const QString SKETCH_RANDOM_OPACITY = "Sketch/randomOpacity";
-const QString SKETCH_DISTANCE_OPACITY = "Sketch/distanceOpacity";
-const QString SKETCH_ANTIALIASING = "Sketch/antiAliasing";
-
-class KisSketchOpOptionsWidget;
-
-class KisSketchOpOption : public KisPaintOpOption
-{
-public:
-    KisSketchOpOption();
-    ~KisSketchOpOption() override;
-
-    void setThreshold(int radius) const;
-    int threshold() const;
-
-    void writeOptionSetting(KisPropertiesConfigurationSP settings) const override;
-    void readOptionSetting(const KisPropertiesConfigurationSP settings) override;
-
-    void lodLimitations(KisPaintopLodLimitations *l) const override;
-
-private:
-
-    KisSketchOpOptionsWidget * m_options;
-
-};
-
-class SketchProperties
-{
-public:
-    qreal offset; // perc
-    qreal probability; // perc
-    bool simpleMode;
-    bool makeConnection;
-    bool magnetify;
-    bool randomRGB;
-    bool randomOpacity;
-    bool distanceOpacity;
-    bool distanceDensity;
-    bool antiAliasing;
-    int lineWidth; // px
-
-    void readOptionSetting(const KisPropertiesConfigurationSP settings) {
-        probability = settings->getDouble(SKETCH_PROBABILITY);
-        offset = settings->getDouble(SKETCH_OFFSET) * 0.01;
-        lineWidth = settings->getInt(SKETCH_LINE_WIDTH);
-        simpleMode = settings->getBool(SKETCH_USE_SIMPLE_MODE);
-        makeConnection = settings->getBool(SKETCH_MAKE_CONNECTION);
-        magnetify = settings->getBool(SKETCH_MAGNETIFY);
-        randomRGB = settings->getBool(SKETCH_RANDOM_RGB);
-        randomOpacity = settings->getBool(SKETCH_RANDOM_OPACITY);
-        distanceDensity = settings->getBool(SKETCH_DISTANCE_DENSITY);
-        distanceOpacity = settings->getBool(SKETCH_DISTANCE_OPACITY);
-        antiAliasing = settings->getBool(SKETCH_ANTIALIASING);
-    }
-};
-
-#endif
diff --git a/plugins/paintops/sketch/wdgsketchoptions.ui b/plugins/paintops/sketch/wdgsketchoptions.ui
index 0ddc44d2559..d805e184f62 100644
--- a/plugins/paintops/sketch/wdgsketchoptions.ui
+++ b/plugins/paintops/sketch/wdgsketchoptions.ui
@@ -49,7 +49,7 @@
        </widget>
       </item>
       <item row="0" column="1">
-       <widget class="KisDoubleSliderSpinBox" name="lineWidthSPBox" native="true">
+       <widget class="KisSliderSpinBox" name="lineWidthSPBox" native="true">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
@@ -192,6 +192,12 @@
    <header>kis_slider_spin_box.h</header>
    <container>1</container>
   </customwidget>
+  <customwidget>
+   <class>KisSliderSpinBox</class>
+   <extends>QWidget</extends>
+   <header>kis_slider_spin_box.h</header>
+   <container>1</container>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>