sequenceeventtrackview.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
 
#include "sequencetrackview.h"
#include "sequencecontrollerevent.h"
#include "sequencetracksegment.h"
#include "sequenceeditorguiclipboard.h"
#include "sequenceeventtrackview_guiactions.h"
#include "sequenceguiutils.h"
 
#include <utility>
#include <imguiutils.h>
 
namespace nap
{
 
    // forward declares
    class SequenceEventTrackView;
    class SequenceGUIService;
 
    class NAPAPI SequenceEventTrackSegmentViewBase
    {
    RTTI_ENABLE()
    public:
        SequenceEventTrackSegmentViewBase() = default;
 
        virtual ~SequenceEventTrackSegmentViewBase() = default;
 
        virtual void handleEditPopupContent(sequenceguiactions::Action& action) = 0;
 
        virtual void drawEvent(const SequenceTrackSegment& segment, ImDrawList* drawList, const ImVec2& topLeft, float x, ImU32 color) = 0;
 
        virtual void insertSegment(SequenceControllerEvent& controller, const std::string& trackID, double time) = 0;
 
        virtual std::unique_ptr<sequenceguiactions::Action> createEditAction(const SequenceTrackSegmentEventBase* segment, const std::string& trackID, const std::string& segmentID) = 0;
    };
 
    template<typename T>
    class NAPAPI SequenceEventTrackSegmentView final : public SequenceEventTrackSegmentViewBase
    {
    RTTI_ENABLE(SequenceEventTrackSegmentViewBase)
    public:
        SequenceEventTrackSegmentView() : SequenceEventTrackSegmentViewBase()
        {}
 
 
        void handleEditPopupContent(sequenceguiactions::Action& action) override;
 
        void drawEvent(const SequenceTrackSegment& segment, ImDrawList* drawList, const ImVec2& topLeft, float x, ImU32 color) override;
 
        void insertSegment(SequenceControllerEvent& controller, const std::string& trackID, double time) override;
 
        std::unique_ptr<sequenceguiactions::Action>
        createEditAction(const SequenceTrackSegmentEventBase* segment, const std::string& trackID, const std::string& segmentID) override;
    };
 
    class NAPAPI SequenceEventTrackView final : public SequenceTrackView
    {
        friend class SequenceGUIService;
 
    RTTI_ENABLE(SequenceTrackView)
    public:
        SequenceEventTrackView(SequenceGUIService& service, SequenceEditorGUIView& view, SequenceEditorGUIState& state);
 
        // make this class explicitly non-copyable
        SequenceEventTrackView(const SequenceEventTrackView&) = delete;
        SequenceEventTrackView& operator=(const SequenceEventTrackView&) = delete;
 
    protected:
        void showInspectorContent(const SequenceTrack& track) override;
 
        void showTrackContent(const SequenceTrack& track, const ImVec2& trackTopLeft) override;
 
        void handleInsertEventSegmentPopup();
 
        template<typename T>
        void handleEditEventSegmentPopup();
 
        bool pasteEventsFromClipboard(const std::string& trackID, double time, utility::ErrorState& errorState);
 
        template<typename T>
        void pasteEvent(const std::string& trackID, const SequenceTrackSegmentEventBase& baseEvent, double time);
 
        void
        drawSegmentHandler(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float segmentX, float segmentWidth, ImDrawList* drawList);
 
        void handleEditSegmentValuePopup();
 
        void updateSegmentInClipboard(const std::string& trackID, const std::string& segmentID);
 
        void handleAssignOutputIDToTrack();
 
        void handleSegmentDrag();
 
        void handleLoadPresetPopup();
 
    private:
        // map of segment views for different event views
        std::unordered_map<rtti::TypeInfo, std::unique_ptr<SequenceEventTrackSegmentViewBase>> mSegmentViews;
    };
 
 
    // Event Clipboards
 
    namespace sequenceguiclipboard
    {
        class EventSegmentClipboard :
            public Clipboard
        {
        RTTI_ENABLE(Clipboard)
        public:
            EventSegmentClipboard(const rttr::type& type, std::string sequenceName)
                : Clipboard(type), mSequenceName(std::move(sequenceName))
            {};
 
 
            const std::string &getSequenceName() const{ return mSequenceName; }
 
        private:
            std::string mSequenceName;
        };
    }
 
    // Template definitions
 
    template<typename T>
    void SequenceEventTrackView::handleEditEventSegmentPopup()
    {
        if(mState.mAction->isAction<sequenceguiactions::OpenEditEventSegmentPopup<T>>())
        {
            // invoke insert sequence popup
            ImGui::OpenPopup("Edit Event");
 
            auto *action = mState.mAction->getDerived<sequenceguiactions::OpenEditEventSegmentPopup<T>>();
            ImGui::SetNextWindowPos(action->mWindowPos);
 
            mState.mAction = sequenceguiactions::createAction<sequenceguiactions::EditingEventSegment<T>>(action->mTrackID, action->mSegmentID, action->mWindowPos, action->mValue, action->mStartTime);
        }
 
        // handle insert segment popup
        if(mState.mAction->isAction<sequenceguiactions::EditingEventSegment<T>>())
        {
            auto *action = mState.mAction->getDerived<sequenceguiactions::EditingEventSegment<T>>();
 
            if(ImGui::BeginPopup("Edit Event"))
            {
                // draw the registered popup content for this event
                auto it = mSegmentViews.find(RTTI_OF(SequenceTrackSegmentEvent<T>));
                assert(it != mSegmentViews.end()); // type not found
                it->second->handleEditPopupContent(*action);
 
                // time
                std::vector<int> time_array = convertTimeToMMSSMSArray(action->mStartTime);
 
                bool edit_time = false;
 
                ImGui::Separator();
                ImGui::PushItemWidth(100.0f * mState.mScale);
 
                edit_time = ImGui::InputInt3("Time (mm:ss:ms)", &time_array[0]);
                time_array[0] = math::clamp<int>(time_array[0], 0, 99999);
                time_array[1] = math::clamp<int>(time_array[1], 0, 59);
                time_array[2] = math::clamp<int>(time_array[2], 0, 99);
 
                ImGui::PopItemWidth();
 
                ImGui::Separator();
 
                if(edit_time)
                {
                    auto &event_controller = getEditor().getController<SequenceControllerEvent>();
                    double new_time = convertMMSSMSArrayToTime(time_array);
                    double time = event_controller.segmentEventStartTimeChange(action->mTrackID, action->mSegmentID, new_time);
                    updateSegmentInClipboard(action->mTrackID, action->mSegmentID);
                    action->mStartTime = time;
                    mState.mDirty = true;
                }
                if(ImGui::ImageButton(mService.getGui().getIcon(icon::ok)))
                {
                    auto &event_controller = getEditor().getController<SequenceControllerEvent>();
                    event_controller.editEventSegment<T>(action->mTrackID, action->mSegmentID, action->mValue);
                    updateSegmentInClipboard(action->mTrackID, action->mSegmentID);
                    mState.mAction = sequenceguiactions::createAction<sequenceguiactions::None>();
                    ImGui::CloseCurrentPopup();
                }
                ImGui::SameLine();
                if(ImGui::ImageButton(mService.getGui().getIcon(icon::cancel)))
                {
                    ImGui::CloseCurrentPopup();
                    mState.mAction = sequenceguiactions::createAction<sequenceguiactions::None>();
                }
 
                action->mWindowPos = ImGui::GetWindowPos();
 
                ImGui::EndPopup();
            } else
            {
                // click outside popup so cancel action
                mState.mAction = sequenceguiactions::createAction<sequenceguiactions::None>();
            }
        }
    }
 
 
    template<typename T>
    void SequenceEventTrackView::pasteEvent(const std::string& trackID, const SequenceTrackSegmentEventBase& baseEvent, double time)
    {
        // obtain controller
        auto &controller = getEditor().getController<SequenceControllerEvent>();
 
        // insert new segment
        const auto *new_segment = dynamic_cast<const T *>(controller.insertEventSegment<T>(trackID,
                                                                                           baseEvent.mStartTime +
                                                                                           time));
        assert(new_segment != nullptr); // cast failed
 
        // upcast de-serialized event
        const auto *event_upcast = dynamic_cast<const T *>(&baseEvent);
        assert(event_upcast != nullptr); // cast failed
 
        // copy values from deserialized event segment
        controller.editEventSegment(trackID, new_segment->mID, event_upcast->mValue);
    }
 
 
    template<typename T>
    void SequenceEventTrackSegmentView<T>::insertSegment(SequenceControllerEvent& controller, const std::string& trackID, double time)
    {
        controller.insertEventSegment<SequenceTrackSegmentEvent<T>>(trackID, time);
    }
 
 
    template<typename T>
    std::unique_ptr<sequenceguiactions::Action> SequenceEventTrackSegmentView<T>::createEditAction(const SequenceTrackSegmentEventBase* segment, const std::string& trackID, const std::string& segmentID)
    {
        const auto* event = static_cast<const SequenceTrackSegmentEvent<T>*>(segment);
        return sequenceguiactions::createAction<sequenceguiactions::OpenEditEventSegmentPopup<T>>(trackID, segmentID, ImGui::GetWindowPos(), event->mValue, segment->mStartTime);
    }
}