portalitemsimple.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 <parametersimple.h>
#include <nap/signalslot.h>
 
namespace nap
{
    template<typename T>
    class PortalItemSimple : 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, &PortalItemSimple::onParameterUpdate };
 
        ResourcePtr<ParameterSimple<T>> mParameter; 
    };
 
 
    // Portal Item Simple Type Definitions
 
    using PortalItemToggle = PortalItemSimple<bool>;
    using PortalItemTextField = PortalItemSimple<std::string>;
    class PortalItemTextArea : public PortalItemSimple<std::string>
    {
        RTTI_ENABLE(PortalItemSimple<std::string>)
    };
 
 
    // Template Definitions
 
    template<typename T>
    bool PortalItemSimple<T>::init(utility::ErrorState& error)
    {
        mParameter->valueChanged.connect(mParameterUpdateSlot);
        return true;
    }
 
    template<typename T>
    void PortalItemSimple<T>::onDestroy()
    {
        mParameter->valueChanged.disconnect(mParameterUpdateSlot);
    }
 
    template<typename T>
    void PortalItemSimple<T>::onParameterUpdate(T value)
    {
        updateSignal(*this);
    }
 
    template<typename T>
    bool PortalItemSimple<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 PortalItemSimple<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);
        return event;
    }
 
    template<typename T>
    APIEventPtr PortalItemSimple<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_SIMPLE(Type)                                                                                 \
    RTTI_BEGIN_CLASS(Type)                                                                                              \
        RTTI_PROPERTY("Parameter",  &Type::mParameter,  nap::rtti::EPropertyMetaData::Required, "Parameter resource")   \
    RTTI_END_CLASS