sequenceeditorguiactions.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
 
// Local Includes
#include "sequencecurveenums.h"
 
// External Includes
#include <rtti/rtti.h>
#include <imgui/imgui.h>
#include <utility>
 
namespace nap
{
    namespace sequenceguiactions
    {
        class NAPAPI Action
        {
        RTTI_ENABLE()
        public:
            virtual ~Action() = default;
 
            template<typename T>
            bool isAction(){ return this->get_type() == RTTI_OF(T); }
 
            template<typename T>
            T* getDerived()
            {
                assert(isAction<T>());
                return static_cast<T *>(this);
            }
        };
 
        // shortcut to unique ptr of action class
        using SequenceActionPtr = std::unique_ptr<Action>;
 
 
        // use this method to create an action
        template<typename T, typename... Args>
        static SequenceActionPtr createAction(Args &&... args)
        {
            return std::make_unique<T>(std::forward<Args>(args)...);
        }
 
 
        class NAPAPI None : public Action
        {
        RTTI_ENABLE()
        };
 
 
        class NAPAPI NonePressed : public Action
        {
        RTTI_ENABLE()
        };
 
 
        class NAPAPI TrackAction : public Action
        {
        RTTI_ENABLE(Action)
        public:
            explicit TrackAction(std::string trackID) : mTrackID(std::move(trackID))
            {}
 
 
            std::string mTrackID;
        };
 
 
        class NAPAPI DraggingSegment : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            DraggingSegment(std::string trackId, std::string segmentID, double newDuration)
                : TrackAction(std::move(trackId)), mSegmentID(std::move(segmentID)), mNewDuration(newDuration)
            {}
 
 
            std::string mSegmentID;
            double mNewDuration;
        };
 
 
        class NAPAPI StartDraggingSegment : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            StartDraggingSegment(std::string trackId, std::string segmentID, double startDuration)
                : TrackAction(std::move(trackId)), mSegmentID(std::move(segmentID)), mStartDuration(startDuration)
            {}
 
 
            std::string mSegmentID;
            double mStartDuration;
        };
 
 
        class NAPAPI InsertingSegmentPopup : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            InsertingSegmentPopup(std::string trackID, double time, const rttr::type &trackType)
                : TrackAction(std::move(trackID)), mTime(time), mTrackType(trackType)
            {}
 
            bool mOpened = false;
            double mTime;
            rttr::type mTrackType;
            std::string mErrorString;
        };
 
 
        class NAPAPI EditSegmentPopup : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            EditSegmentPopup(std::string trackID, std::string segmentID, const rttr::type &segmentType)
                : TrackAction(std::move(trackID)), mSegmentID(std::move(segmentID)), mSegmentType(segmentType)
            {}
 
            bool mOpened = false;
            std::string mSegmentID;
            rttr::type mSegmentType;
        };
 
 
        class NAPAPI HoveringSegment : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            HoveringSegment(std::string trackID, std::string segmentID)
                : TrackAction(std::move(trackID)), mSegmentID(std::move(segmentID))
            {}
 
 
            std::string mSegmentID;
        };
 
 
        class NAPAPI HoveringPlayerTime : public Action
        {
        RTTI_ENABLE(Action)
        };
 
 
        class NAPAPI DraggingPlayerTime : public Action
        {
        RTTI_ENABLE(Action)
        public:
            DraggingPlayerTime(bool wasPlaying, bool wasPaused)
                : mWasPlaying(wasPlaying), mWasPaused(wasPaused)
            {}
 
 
            bool mWasPlaying;
            bool mWasPaused;
        };
 
 
        class NAPAPI InsertTrackPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            // indicates whether the handler should open the popup
            bool mOpened = false;
        };
 
 
        class LoadPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            int mSelectedShowIndex = 0;
            std::string mErrorString;
        };
 
 
        class NAPAPI SaveAsPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            int mSelectedShowIndex = 0;
            std::string mErrorString;
        };
 
 
        class NAPAPI HoveringSequenceDuration : public Action
        {
        RTTI_ENABLE(Action)
        public:
        };
 
 
        class NAPAPI DraggingSequenceDuration : public Action
        {
        RTTI_ENABLE(Action)
        public:
        };
 
 
        class NAPAPI EditSequenceDurationPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            // indicates whether the handler should open the popup
            bool mOpened = false;
        };
 
 
        class NAPAPI EditSequenceMarkerPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            EditSequenceMarkerPopup(std::string id, std::string message, double time)
                : mID(std::move(id)), mMessage(std::move(message)), mTime(time)
            {}
 
            // marker id
            std::string mID;
            // indicates whether the handler should open the popup
            bool mOpened = false;
            // time of the marker
            double mTime;
            // marker message content
            std::string mMessage = "Message";
        };
 
 
        class NAPAPI InsertingSequenceMarkerPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            InsertingSequenceMarkerPopup(double time)
                : mTime(time)
            {}
 
            // indicates whether the handler should open the popup
            bool mOpened = false;
            // time of the marker
            double mTime;
            // marker message content
            std::string mMessage = "Message";
        };
 
 
        class NAPAPI DragSequenceMarker : public Action
        {
        RTTI_ENABLE(Action)
        public:
            explicit DragSequenceMarker(std::string id) : mID(std::move(id))
            {}
 
 
            std::string mID;
        };
 
 
        class NAPAPI AssignOutputIDToTrack : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            AssignOutputIDToTrack(const std::string& trackID, std::string outputID)
                : TrackAction(trackID), mOutputID(std::move(outputID))
            {}
 
 
            std::string mOutputID;
 
        };
 
 
        class NAPAPI HelpPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            // indicates whether the handler should open the popup
            bool mOpened = false;
        };
 
        class ChangeHorizontalResolution : public Action
        {
        RTTI_ENABLE(Action)
        public:
            ChangeHorizontalResolution(float newResolution) : mHorizontalResolution(newResolution)
            {}
 
 
            float mHorizontalResolution;
        };
 
        class ChangeTrackName : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            ChangeTrackName(const std::string& id, const std::string& newName) : TrackAction(id), mNewTrackName(newName)
            {}
 
 
            std::string mNewTrackName;
        };
 
        class HoveringTrackExtensionHandler : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            HoveringTrackExtensionHandler(std::string trackId) : TrackAction(std::move(trackId))
            {}
        };
 
        class DraggingTrackExtensionHandler : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            DraggingTrackExtensionHandler(std::string trackId) : TrackAction(std::move(trackId))
            {}
        };
 
        class SavePresetPopup : public Action
        {
        RTTI_ENABLE(Action)
        public:
            SavePresetPopup(const std::string& filePath)
                : mFilePath(filePath)
            {}
 
 
            std::string mFilePath;
            int mSelectedPresetIndex = 0;
            std::string mErrorString;
        };
 
        class LoadPresetPopup : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            LoadPresetPopup(const std::string& id, double time, rtti::TypeInfo trackType)
                : TrackAction(id), mTime(time), mTrackType(trackType)
            {}
 
 
            std::string mFilePath;
            rtti::TypeInfo mTrackType;
            int mSelectedPresetIndex = 0;
            std::string mErrorString;
            double mTime;
        };
 
        class TrackOptionsPopup : public TrackAction
        {
        RTTI_ENABLE(TrackAction)
        public:
            TrackOptionsPopup(const std::string& trackID, ImVec2 pos)
                    : TrackAction(trackID), mPos(std::move(pos))
            {}
 
            // indicates whether the handler should open the popup
            bool mPopupOpened = false;
            // position of the popup in screen coordinates
            ImVec2 mPos;
            // scroll at the moment of opening, popup closes when the user scrolls within the sequence editor gui
            float mScrollY = 0.0f;
        };
    }
}