sequenceeditor.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
 
// internal includes
#include "sequence.h"
#include "sequencecontroller.h"
#include "sequencecurveenums.h"
#include "sequenceplayer.h"
#include "sequenceservice.h"
#include "sequenceservice.h"
 
// external includes
#include <nap/resource.h>
#include <parameter.h>
#include <nap/logger.h>
#include <atomic>
 
namespace nap
{
 
    // forward declares
    class SequenceController;
 
    class NAPAPI SequenceEditor : public Resource
    {
        friend class SequenceController;
 
    RTTI_ENABLE(Resource)
    public:
        SequenceEditor(SequenceService& service);
 
        bool init(utility::ErrorState& errorState) override;
 
        void save(const std::string& file);
 
        void load(const std::string& file);
 
        void changeSequenceDuration(double newDuration);
 
        SequenceController *getControllerWithTrackType(rtti::TypeInfo trackType);
 
        SequenceController* getControllerWithTrackID(const std::string& trackID);
 
 
        template<typename T>
        T &getController()
        {
            assert(mControllers.find(RTTI_OF(T)) != mControllers.end()); // type not found
            return static_cast<T &>(*mControllers[RTTI_OF(T)].get());
        }
 
 
        void insertMarker(double time, const std::string& message);
 
        void changeMarkerTime(const std::string& markerID, double time);
 
        void deleteMarker(const std::string& markerID);
 
        void changeMarkerMessage(const std::string& markerID, const std::string& markerMessage);
 
        // properties
        ResourcePtr<SequencePlayer> mSequencePlayer = nullptr; 
    private:
        // map of all controllers
        std::unordered_map<rttr::type, std::unique_ptr<SequenceController>> mControllers;
 
        void performEdit(std::function<void()> action);
 
        // make sure we don't perform two edit actions at the same time and make sure they are executed on the main thread
        // during the update call to the SequenceEditor
        std::atomic_bool mPerformingEditAction = {false};
 
        // service reference
        SequenceService& mService;
    };
 
    using SequenceEditorObjectCreator = rtti::ObjectCreator<SequenceEditor, SequenceService>;
}