PhosphorCurve.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorAnimation/Curve.h>
#include <PhosphorAnimation/phosphoranimation_export.h>
#include <PhosphorAnimation/PhosphorEasing.h>
#include <PhosphorAnimation/PhosphorSpring.h>
 
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtQml/qqmlregistration.h>
 
#include <atomic>
#include <memory>
 
namespace PhosphorAnimation {
 
class CurveRegistry;
 
class PHOSPHORANIMATION_EXPORT PhosphorCurve
{
    Q_GADGET
    QML_VALUE_TYPE(phosphorCurve)
    // No QML_STRUCTURED_VALUE — PhosphorCurve is opaque; the caller
    // constructs it via factory functions (fromEasing/fromSpring/
    // fromString) rather than a struct literal.
 
    Q_PROPERTY(QString typeId READ typeId)
 
public:
    PhosphorCurve() = default;
    explicit PhosphorCurve(std::shared_ptr<const Curve> curve)
        : m_curve(std::move(curve))
    {
    }
 
    std::shared_ptr<const Curve> curve() const
    {
        return m_curve;
    }
 
    QString typeId() const
    {
        return m_curve ? m_curve->typeId() : QString();
    }
 
    Q_INVOKABLE QString toString() const
    {
        return m_curve ? m_curve->toString() : QString();
    }
 
    Q_INVOKABLE bool isNull() const
    {
        return !m_curve;
    }
 
    // ─── Registry wiring ───
 
    static void setDefaultRegistry(CurveRegistry* registry);
 
    static CurveRegistry* defaultRegistry()
    {
        return s_registry.load(std::memory_order_acquire);
    }
 
    // ─── Factory helpers ───
 
    Q_INVOKABLE static PhosphorCurve fromString(const QString& str);
 
    Q_INVOKABLE static PhosphorCurve fromEasing(const PhosphorEasing& easing);
 
    Q_INVOKABLE static PhosphorCurve fromSpring(const PhosphorSpring& spring);
 
    // ─── Equality ───
 
    bool operator==(const PhosphorCurve& other) const
    {
        if (m_curve == other.m_curve) {
            return true;
        }
        if (!m_curve || !other.m_curve) {
            return false;
        }
        return m_curve->equals(*other.m_curve);
    }
    bool operator!=(const PhosphorCurve& other) const
    {
        return !(*this == other);
    }
 
private:
    // Atomic so concurrent QML loaders (multiple QQmlEngine instances
    // on different threads — a background-prerender shell is the
    // canonical case) cannot race on install-vs-read. Pointer loads
    // are lock-free on every platform Qt supports; `relaxed` ordering
    // is sufficient because the registry object's own initialisation
    // is synchronised by the composition root's construction (the
    // pointed-to `CurveRegistry` is already fully constructed before
    // the publishing thread calls setDefaultRegistry).
    static std::atomic<CurveRegistry*> s_registry;
    std::shared_ptr<const Curve> m_curve;
};
 
} // namespace PhosphorAnimation
 
Q_DECLARE_METATYPE(PhosphorAnimation::PhosphorCurve)