NewModelCommand.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignCommand.h>
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/TranslatedString.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief A DesignCommand that creates a new Model to some specification
    **/
    class NewModelCommand : public DesignCommand
    {
    public:
        NewModelCommand(const TranslatedString& name, const std::function<void(Model& model)>& model)
            : DesignCommand()
            , on_create(model)
            , model_name(name)
        {}
        virtual String 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.setProperty(DesignObject::e_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.uuid());
                    if (finished_callback)
                        finished_callback(scene);
                }
                else
                {
                    WLock lock(lookup->writeLock());
                    Model parent(lookup->model(parent_id));
                    Model model = parent.createChild();
                    model.setProperty(DesignObject::e_name, model_name);
                    if (on_create)
                        on_create(model);
                    lookup->addModel(model);
                    parent.updateModifiedTime();
                    targets.add(model.uuid());
                    if (finished_callback)
                        finished_callback(model);
                    
                }
                
            }
        }
        std::function<void(Model& model)> on_create;
        std::function<void(Model& model)> finished_callback;
        TranslatedString model_name;
        UUID parent_id;
        String type;
    };
}