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>
#include <rtti/binarywriter.h>
 
namespace nap
{
 
    // forward declares
    class SequenceController;
 
    struct NAPAPI SequenceEditorHistoryPoint
    {
        SequenceEditorHistoryPoint(DateTime dateTime, rtti::TypeInfo actionType) :
                mDateTime(dateTime), mActionType(actionType)
        { }
 
        DateTime mDateTime;
        rtti::TypeInfo mActionType;
        rtti::BinaryWriter mBinaryWriter;
    };
 
    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);
 
        void takeSnapshot(rtti::TypeInfo actionType);
 
        void undo();
 
        void redo();
 
        void jumpToHistoryPointIndex(int index);
 
        void clearHistory();
 
        const std::deque<std::unique_ptr<SequenceEditorHistoryPoint>>& getHistory() const{ return mHistory; }
 
        size_t getHistoryIndex() const{ return mHistoryIndex; }
 
        size_t getHistorySize() const{ return mHistory.size(); }
 
        // properties
        ResourcePtr<SequencePlayer> mSequencePlayer = nullptr; 
        int mUndoSteps = 100; 
    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;
 
        // History index
        int mHistoryIndex = 0;
 
        // History
        std::deque<std::unique_ptr<SequenceEditorHistoryPoint>> mHistory;
    };
 
    using SequenceEditorObjectCreator = rtti::ObjectCreator<SequenceEditor, SequenceService>;
}