kis_dynamic_sensor.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2006 Cyrille Berger <[email protected]>
 *  Copyright (c) 2011 Lukáš Tvrdý <[email protected]>
 *
 *  This library is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#ifndef _KIS_DYNAMIC_SENSOR_H_
#define _KIS_DYNAMIC_SENSOR_H_
 
#include <kritapaintop_export.h>
 
#include <QObject>
 
#include <KoID.h>
 
#include <klocalizedstring.h>
 
#include "kis_serializable_configuration.h"
#include "kis_curve_label.h"
#include <kis_cubic_curve.h>
#include <kis_shared_ptr.h>
#include <kis_shared.h>
 
 
class QWidget;
class KisPaintInformation;
 
const KoID FuzzyPerDabId("fuzzy", ki18nc("Context: dynamic sensors", "Fuzzy Dab")); 
const KoID FuzzyPerStrokeId("fuzzystroke", ki18nc("Context: dynamic sensors", "Fuzzy Stroke")); 
const KoID SpeedId("speed", ki18nc("Context: dynamic sensors", "Speed")); 
const KoID FadeId("fade", ki18nc("Context: dynamic sensors", "Fade")); 
const KoID DistanceId("distance", ki18nc("Context: dynamic sensors", "Distance")); 
const KoID TimeId("time", ki18nc("Context: dynamic sensors", "Time")); 
const KoID DrawingAngleId("drawingangle", ki18nc("Context: dynamic sensors", "Drawing angle")); 
const KoID RotationId("rotation", ki18nc("Context: dynamic sensors", "Rotation")); 
const KoID PressureId("pressure", ki18nc("Context: dynamic sensors", "Pressure")); 
const KoID PressureInId("pressurein", ki18nc("Context: dynamic sensors", "PressureIn")); 
const KoID XTiltId("xtilt", ki18nc("Context: dynamic sensors", "X-Tilt")); 
const KoID YTiltId("ytilt", ki18nc("Context: dynamic sensors", "Y-Tilt")); 
 
const KoID TiltDirectionId("ascension", ki18nc("Context: dynamic sensors", "Tilt direction")); 
const KoID TiltElevationId("declination", ki18nc("Context: dynamic sensors", "Tilt elevation")); 
 
const KoID PerspectiveId("perspective", ki18nc("Context: dynamic sensors", "Perspective")); 
const KoID TangentialPressureId("tangentialpressure", ki18nc("Context: dynamic sensors", "Tangential pressure")); 
const KoID SensorsListId("sensorslist", "SHOULD NOT APPEAR IN THE UI !"); 
 
class KisDynamicSensor;
typedef KisSharedPtr<KisDynamicSensor> KisDynamicSensorSP;
 
enum DynamicSensorType {
    FUZZY_PER_DAB,
    FUZZY_PER_STROKE,
    SPEED,
    FADE,
    DISTANCE,
    TIME,
    ANGLE,
    ROTATION,
    PRESSURE,
    XTILT,
    YTILT,
    TILT_DIRECTION,
    TILT_ELEVATATION,
    PERSPECTIVE,
    TANGENTIAL_PRESSURE,
    SENSORS_LIST,
    PRESSURE_IN,
 
    MYPAINT_PRESSURE,
    MYPAINT_FINE_SPEED,
    MYPAINT_GROSS_SPEED,
    MYPAINT_RANDOM,
    MYPAINT_STROKE,
    MYPAINT_DIRECTION,
    MYPAINT_DECLINATION,
    MYPAINT_ASCENSION,
    MYPAINT_CUSTOM,
 
    UNKNOWN = 255
};
 
class PAINTOP_EXPORT KisDynamicSensor : public KisSerializableConfiguration
{
 
public:
    enum ParameterSign {
        NegativeParameter = -1,
        UnSignedParameter = 0,
        PositiveParameter = 1
    };
 
protected:
    KisDynamicSensor(DynamicSensorType type);
 
public:
 
    ~KisDynamicSensor() override;
 
    qreal parameter(const KisPaintInformation& info);
    qreal parameter(const KisPaintInformation& info, const KisCubicCurve curve, const bool customCurve);
 
    virtual void reset();
 
    virtual QWidget* createConfigurationWidget(QWidget* parent, QWidget* selector);
 
    static KisDynamicSensorSP id2Sensor(const KoID& id, const QString &parentOptionName);
    static KisDynamicSensorSP id2Sensor(const QString& s, const QString &parentOptionName) {
        return id2Sensor(KoID(s), parentOptionName);
    }
 
    virtual QString minimumLabel(DynamicSensorType sensorType);
    virtual QString maximumLabel(DynamicSensorType sensorType, int max = -1);
    virtual int minimumValue(DynamicSensorType sensorType);
    virtual int maximumValue(DynamicSensorType sensorType, int max = -1);
    virtual QString valueSuffix(DynamicSensorType sensorType);
 
    static KisDynamicSensorSP createFromXML(const QString&, const QString &parentOptionName);
    static KisDynamicSensorSP createFromXML(const QDomElement&, const QString &parentOptionName);
 
 
    static QString id(DynamicSensorType sensorType);
 
    using KisSerializableConfiguration::fromXML;
    using KisSerializableConfiguration::toXML;
 
    void toXML(QDomDocument&, QDomElement&) const override;
    void fromXML(const QDomElement&) override;
 
    void setCurve(const KisCubicCurve& curve);
    const KisCubicCurve& curve() const;
    void removeCurve();
    bool hasCustomCurve() const;
 
    void setActive(bool active);
    bool isActive() const;
 
    virtual bool dependsOnCanvasRotation() const;
 
    virtual bool isAdditive() const;
    virtual bool isAbsoluteRotation() const;
 
    inline DynamicSensorType sensorType() const { return m_type; }
 
 
    int length() { return m_length; }
    QString identifier();
 
 
public:
    static inline qreal scalingToAdditive(qreal x) {
        return -1.0 + 2.0 * x;
    }
 
    static inline qreal additiveToScaling(qreal x) {
        return 0.5 * (1.0 + x);
    }
 
protected:
 
    virtual qreal value(const KisPaintInformation& info) = 0;
 
    int m_length;
    QString m_id;
 
    DynamicSensorType m_type;
    bool m_customCurve;
    KisCubicCurve m_curve;
    bool m_active;
 
private:
    Q_DISABLE_COPY(KisDynamicSensor)
 
};
 
#endif