QeAngleLineEdit.hpp

#ifndef QEANGLELINEEDIT_H
#define QEANGLELINEEDIT_H
 
#include <QDoubleSpinBox>
#include <QDebug>

class QeAngleLineEdit : public QDoubleSpinBox {
    Q_OBJECT
    Q_PROPERTY(Units unit READ getUnits WRITE setUnits NOTIFY unitChanged)
    Q_PROPERTY(double radians READ getRadians WRITE setRadians NOTIFY radiansChanged )
    Q_PROPERTY(int precision READ getPrecision WRITE setPrecision NOTIFY precisionChanged )
    Q_PROPERTY(double minimum READ getMinimum WRITE setMinimum NOTIFY minimumChanged )
    Q_PROPERTY(double maximum READ getMaximum WRITE setMaximum NOTIFY maximumChanged )
 
 
public:
    enum class Units {
        SEXAGESIMAL, 
        RADIANS,     
        HMS,         
        DMS          
    };
    Q_ENUM(Units)
 
    
    explicit QeAngleLineEdit(QWidget* parent = nullptr);

    [[deprecated("Please use getUnits() instead")]]
    Units getUnit() const { return getUnits(); }

    Units getUnits() const { return m_unit; }

    int getPrecision() { return decimals(); }

    double getRadians() { return value(); }

    double getMinimum() { return minimum(); }

    double getMaximum() { return maximum(); }
 
signals:
    void unitChanged(Units newUnit);

    void validationStateChanged(QValidator::State state);

    void radiansChanged(double radians);

    void precisionChanged(int precision);

    void minimumChanged(double minimum);

    void maximumChanged(double maximum);
 
public slots:
    [[deprecated("Please use setUnits(Units unit) instead")]]
    void setUnit(Units unit);

    void setUnits(Units unit);

    void setPrecision(int newValue) { setDecimals(newValue); emit precisionChanged(newValue); }

    void setRadians(double newValue) { setValue(newValue); }

    void setUnitsInt(int unit) {
        Units enum_unit = static_cast<Units>(unit);
        setUnits(enum_unit);
    }

    void setMinimum(double newValue) {
        if (qFuzzyCompare(minimum(), newValue))
            return;
 
        QDoubleSpinBox::setMinimum(newValue);
        emit minimumChanged(newValue);
    }

    void setMaximum(double newValue) {
        if (qFuzzyCompare(maximum(), newValue))
            return;
 
        QDoubleSpinBox::setMaximum(newValue);
        emit maximumChanged(newValue);
    }
 
protected:
    QString textFromValue(double value) const override;

    double valueFromText(const QString& text) const override;

    QValidator::State validate(QString& input, int& pos) const override;

    void handleState(QValidator::State state);
 
private:
    Units m_unit;

    QString formatHMS(double value) const;

    double parseHMS(const QString& text, bool& ok) const;

    QString formatDMS(double value) const;

    double parseDMS(const QString& text, bool& ok) const;

    QString formatDegrees(double value) const;

    double parseDegrees(const QString& text, bool& ok) const;

    double parseRadians(const QString& text, bool& ok) const;
};
 
 
#endif // QEANGLELINEEDIT_H