SetPropertiesCommand.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignCommand.h>
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Material.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/DesignParameter.h>
#include <NDEVR/Translator.h>
namespace NDEVR
{
    template<auto t_property, class t_type = typename PropertySpec<t_property>::type>
    class SetProperty : public DesignCommand
    {
    public:
        SetProperty()
        {}

        SetProperty(const DesignObject& object, const t_type& value)
            : value(value)
            , m_target(object.get<NDPO::guid>())
            , m_previous_value(value)
        {}

        SetProperty(const t_type& value)
            : value(value)
            , m_target(Constant<UUID>::Invalid)
            , m_previous_value(value)
        {}

        SetProperty(const SetProperty<t_property, t_type>& value)
            : DesignCommand(value)
            , value(value.value)
            , m_target(value.m_target)
            , m_previous_value(value.m_previous_value)
        {
        }

        virtual StringView icon() const override
        {
            return "about";
        }

        virtual TranslatedString name() const override
        {
            return _t("Set Property");
        }

        void execute(DesignObjectLookup* lookup) override
        {
            WLock lock(lookup->writeLock());
            DesignObject object = lookup->object(m_target);
            if (is_undo)
            {
                object.update<t_property>(m_previous_value);
            }
            else
            {
                m_previous_value = object.get<t_property, t_type>();
                object.update<t_property>(value);
            }
        }

        virtual bool addTarget(UUID target_id) override { m_target = target_id; return true; }
        t_type value; 
    protected:
        UUID m_target; 
        t_type m_previous_value; 
    };

    template<auto t_property, class t_type = typename PropertySpec<t_property>::type>
    class SetProperties : public DesignCommand
    {
    public:
        SetProperties()
        {
        }

        SetProperties(t_type value)
            : value(value)
        {
        }

        virtual StringView icon() const override
        {
            return "about";
        }

        virtual TranslatedString name() const override
        {
            return _t("Set Properties");
        }

        void execute(DesignObjectLookup* lookup)
        {
            WLock lock(lookup->writeLock());
            if (!is_undo)
                m_previous_values.clear(targets.size());
            for (uint04 i = 0; i < targets.size(); i++)
            {
                DesignObject object = lookup->object(targets[i]);
                if (!object.isValid())
                    continue;
                t_type previous_value;
                if (is_undo)
                {
                    object.update<t_property>(m_previous_values[i]);
                }
                else
                {
                    m_previous_values.add(object.get<t_property, t_type>());
                    object.update<t_property>(value);
                }
            }
        }

        virtual bool addTarget(UUID target_id) override { targets.add(target_id); return true; }
        t_type value; 
        Buffer<UUID> targets; 
    protected:
        Buffer<t_type> m_previous_values; 
    };

    class SetPropertiesCommand : public DesignCommand
    {
    public:
        struct PropertyValue
        {
            UUID target; 
            DesignParameter parameter; 
            String value; 
        };

        SetPropertiesCommand()
        {}

        virtual StringView icon() const override
        {
            return "about";
        }

        virtual TranslatedString name() const override
        {
            return _t("Set Properties");
        }

        NDEVR_DESIGN_API virtual void execute(DesignObjectLookup* lookup) override;
        template<class t_type>
        void add(const DesignObject& obj, NDPO prop, const t_type& value)
        {
            properties.add({ obj.get<NDPO::guid>(), DesignParameter(prop), String(value) });
        }

        template<class t_type>
        void add(const Geometry& geo, NDPG prop, const t_type& value)
        {
            properties.add({ geo.get<NDPO::guid>(), DesignParameter(prop), String(value) });
        }

        template<class t_type>
        void add(const Material& mat, NDPM prop, const t_type& value)
        {
            properties.add({ mat.get<NDPO::guid>(), DesignParameter(prop), String(value) });
        }

        virtual bool addTarget(UUID) override { return false; }
    public:
        Buffer<PropertyValue> properties; 
    };
}