PhosphorSpring.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorAnimation/Spring.h>
#include <PhosphorAnimation/phosphoranimation_export.h>
 
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtQml/qqmlregistration.h>
 
namespace PhosphorAnimation {
 
class PHOSPHORANIMATION_EXPORT PhosphorSpring
{
    Q_GADGET
    QML_VALUE_TYPE(phosphorSpring)
    QML_STRUCTURED_VALUE
 
    Q_PROPERTY(qreal omega READ omega WRITE setOmega)
    Q_PROPERTY(qreal zeta READ zeta WRITE setZeta)
 
public:
    PhosphorSpring() = default;
    explicit PhosphorSpring(const Spring& value)
        : m_value(value)
    {
    }
    PhosphorSpring(qreal omega, qreal zeta)
        : m_value(omega, zeta)
    {
    }
 
    const Spring& value() const
    {
        return m_value;
    }
 
    // ─── Property delegates ───
 
    qreal omega() const
    {
        return m_value.omega;
    }
    void setOmega(qreal v)
    {
        // Re-construct through the Spring ctor so bounds-clamping is
        // shared with the C++ path. Direct field writes bypass the
        // clamp which would let a settings UI sneak a pathological
        // value past the contract.
        m_value = Spring(v, m_value.zeta);
    }
    qreal zeta() const
    {
        return m_value.zeta;
    }
    void setZeta(qreal v)
    {
        m_value = Spring(m_value.omega, v);
    }
 
    // ─── Serialization ───
 
    Q_INVOKABLE QString toString() const
    {
        return m_value.toString();
    }
 
    Q_INVOKABLE static PhosphorSpring fromString(const QString& str)
    {
        return PhosphorSpring(Spring::fromString(str));
    }
 
    // ─── Presets ───
 
    Q_INVOKABLE static PhosphorSpring snappy()
    {
        return PhosphorSpring(Spring::snappy());
    }
    Q_INVOKABLE static PhosphorSpring smooth()
    {
        return PhosphorSpring(Spring::smooth());
    }
    Q_INVOKABLE static PhosphorSpring bouncy()
    {
        return PhosphorSpring(Spring::bouncy());
    }
 
    // ─── Equality ───
 
    bool operator==(const PhosphorSpring& other) const
    {
        return m_value == other.m_value;
    }
    bool operator!=(const PhosphorSpring& other) const
    {
        return !(*this == other);
    }
 
private:
    Spring m_value;
};
 
} // namespace PhosphorAnimation
 
Q_DECLARE_METATYPE(PhosphorAnimation::PhosphorSpring)