Port Sketch engine to Lager

Refactors kis_sketchop_option into
KisSketchOpOption Data/Model/Widget files,
and density, linewidth, and offset_scale options
into KisSketchStandardOptions / OptionData.

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 )

plugins/paintops/sketch/KisSketchOpOptionData.cpp

@@ -0,0 +1,62 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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;
+}

plugins/paintops/sketch/KisSketchOpOptionData.h

@@ -0,0 +1,50 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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

plugins/paintops/sketch/KisSketchOpOptionModel.cpp

@@ -0,0 +1,27 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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]}
+{
+}

plugins/paintops/sketch/KisSketchOpOptionModel.h

@@ -0,0 +1,36 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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

plugins/paintops/sketch/KisSketchOpOptionWidget.cpp

@@ -0,0 +1,100 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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);
+}

plugins/paintops/sketch/KisSketchOpOptionWidget.h

@@ -0,0 +1,34 @@
+/*
+ *  SPDX-FileCopyrightText: 2010 Lukáš Tvrdý <[email protected]>
+ *
+ *  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

plugins/paintops/sketch/KisSketchStandardOptionData.h

@@ -0,0 +1,41 @@
+/*
+ *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <[email protected]>
+ *
+ *  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

plugins/paintops/sketch/KisSketchStandardOptions.h

@@ -0,0 +1,16 @@
+/*
+ *  SPDX-FileCopyrightText: 2011 Lukáš Tvrdý <[email protected]>
+ *
+ *  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