NewModelCommand.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignCommand.h>
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/TranslatedString.h>
namespace NDEVR
{
    class NewModelCommand : public DesignCommand
    {
    public:
        NewModelCommand(const TranslatedString& name, const std::function<void(Model& model)>& on_finished)
            : DesignCommand()
            , on_create(on_finished)
            , model_name(name)
        {}

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

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

        virtual void execute(DesignObjectLookup* lookup) override
        {
            if (is_undo)
            {
                WLock lock(lookup->writeLock());
                for(UUID target_id : targets)
                    lookup->deleteObject(target_id);
                targets.clear();
            }
            else
            {
                if (targets.size() > 0)
                {
                    WLock lock(lookup->writeLock());
                    for (uint04 i = 0; i < targets.size(); i++)
                    {
                        if (lookup->hasModelID(targets[i], true))
                        {
                            lookup->restoreModel(targets[i]);
                        }
                        else
                        {
                            Scene scene(model_name);
                            if (on_create)
                                on_create(scene);
                            scene.set<NDPO::guid>(targets[i]);
                            lookup->addScene(scene);
                            if (finished_callback)
                                finished_callback(scene);
                        }
                    }
 
                }
                else if (IsInvalid(parent_id))
                {
                    Scene scene(model_name);
                    if (on_create)
                        on_create(scene);
                    WLock lock(lookup->writeLock());
                    lookup->addScene(scene);
                    targets.add(scene.get<NDPO::guid>());
                    if (finished_callback)
                        finished_callback(scene);
                }
                else
                {
                    WLock lock(lookup->writeLock());
                    Model parent(lookup->model(parent_id));
                    Model model = parent.createChild();
                    model.set<NDPOC::name>(model_name);
                    if (on_create)
                        on_create(model);
                    lookup->addModel(model);
                    parent.updateModifiedTime();
                    targets.add(model.get<NDPO::guid>());
                    if (finished_callback)
                        finished_callback(model);
 
                }
 
            }
        }

        virtual bool addTarget(UUID target_id) override { targets.add(target_id); return true; }
    public:
        std::function<void(Model& model)> on_create;            
        std::function<void(Model& model)> finished_callback;    
        TranslatedString model_name;                            
        UUID parent_id;                                         
        Buffer<UUID> targets;                                   
    };
}