portalitemnumeric.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "portalitem.h"
#include "portalutils.h"
 
// External Includes
#include <apivalue.h>
#include <apievent.h>
#include <parameternumeric.h>
#include <nap/signalslot.h>
 
namespace nap
{
    template<typename T>
    class PortalItemNumeric : public PortalItem
    {
        RTTI_ENABLE(PortalItem)
    public:
 
        virtual bool init(utility::ErrorState& error) override;
 
        virtual void onDestroy() override;
 
        virtual bool processUpdate(const APIEvent& event, utility::ErrorState& error) override;
 
        virtual APIEventPtr getDescriptor() const override;
 
        virtual APIEventPtr getValue() const override;
 
        virtual void onParameterUpdate(T value);
 
        Slot<T> mParameterUpdateSlot = { this, &PortalItemNumeric::onParameterUpdate };
 
        ResourcePtr<ParameterNumeric<T>> mParameter;    
    };
 
 
    // Portal Item Numeric Type Definitions
 
    using PortalItemSliderByte      = PortalItemNumeric<uint8_t>;
    using PortalItemSliderInt       = PortalItemNumeric<int>;
    using PortalItemSliderLong      = PortalItemNumeric<int64_t>;
    using PortalItemSliderFloat     = PortalItemNumeric<float>;
    using PortalItemSliderDouble    = PortalItemNumeric<double>;
 
 
    // Template Definitions
 
    template<typename T>
    bool PortalItemNumeric<T>::init(utility::ErrorState& error)
    {
        mParameter->valueChanged.connect(mParameterUpdateSlot);
        return true;
    }
 
    template<typename T>
    void PortalItemNumeric<T>::onDestroy()
    {
        mParameter->valueChanged.disconnect(mParameterUpdateSlot);
    }
 
    template<typename T>
    void PortalItemNumeric<T>::onParameterUpdate(T value)
    {
        updateSignal(*this);
    }
 
    template<typename T>
    bool PortalItemNumeric<T>::processUpdate(const APIEvent& event, utility::ErrorState& error)
    {
        // Check for the portal item value argument
        const APIArgument* arg = event.getArgumentByName(nap::portal::itemValueArgName);
        if (!error.check(arg != nullptr, "%s: update event missing argument %s", mID.c_str(), nap::portal::itemValueArgName))
            return false;
 
        // Check the portal item value type
        const rtti::TypeInfo type = arg->getValueType();
        if (!error.check(type == RTTI_OF(T), "%s: cannot process value type %s", mID.c_str(), type.get_name().data()))
            return false;
 
        // Cast and set the value on the parameter
        T value = static_cast<const APIValue<T>*>(&arg->getValue())->mValue;
        mParameter->valueChanged.disconnect(mParameterUpdateSlot);
        mParameter->setValue(value);
        mParameter->valueChanged.connect(mParameterUpdateSlot);
        return true;
    }
 
    template<typename T>
    APIEventPtr PortalItemNumeric<T>::getDescriptor() const
    {
        APIEventPtr event = std::make_unique<APIEvent>(mParameter->getDisplayName(), mID);
        event->addArgument<APIString>(nap::portal::itemTypeArgName, get_type().get_name().data());
        event->addArgument<APIValue<T>>(nap::portal::itemValueArgName, mParameter->mValue);
        event->addArgument<APIValue<T>>(nap::portal::itemMinArgName, mParameter->mMinimum);
        event->addArgument<APIValue<T>>(nap::portal::itemMaxArgName, mParameter->mMaximum);
        return event;
    }
 
    template<typename T>
    APIEventPtr PortalItemNumeric<T>::getValue() const
    {
        APIEventPtr event = std::make_unique<APIEvent>(mParameter->getDisplayName(), mID);
        event->addArgument<APIValue<T>>(nap::portal::itemValueArgName, mParameter->mValue);
        return event;
    }
}
 
#define DEFINE_PORTAL_ITEM_NUMERIC(Type)                                                                                \
    RTTI_BEGIN_CLASS(Type, "Numeric portal item")                                                                       \
        RTTI_PROPERTY("Parameter",  &Type::mParameter,  nap::rtti::EPropertyMetaData::Required, "Numeric parameter")    \
    RTTI_END_CLASS