sequencecurvetrackview.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 <utility>
 
#include "sequencetrackview.h"
#include "sequencetracksegmentcurve.h"
#include "sequencecontrollercurve.h"
#include "sequenceguiservice.h"
 
namespace nap
{
 
    class NAPAPI SequenceCurveTrackView final : public SequenceTrackView
    {
    RTTI_ENABLE(SequenceTrackView)
    public:
        SequenceCurveTrackView(SequenceGUIService& service, SequenceEditorGUIView& view, SequenceEditorGUIState& state);
 
        // make this class explicitly non-copyable
        SequenceCurveTrackView(const SequenceCurveTrackView&) = delete;
        SequenceCurveTrackView& operator=(const SequenceCurveTrackView&) = delete;
 
        void handleActions() override;
 
    protected:
        template<typename T>
        void drawSegmentContent(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float previousSegmentX, float segmentWidth, float segmentX, ImDrawList* drawList, bool drawStartValue);
 
        template<typename T>
        void drawSegmentValue(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float segmentX, float segmentWidth, sequencecurveenums::ESegmentValueTypes segmentType, ImDrawList* drawList);
 
        void drawSegmentHandler(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float segmentX, float segmentWidth, ImDrawList* drawList);
 
        template<typename T>
        void drawControlPoints(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float segmentX, float segmentWidth, ImDrawList* drawList);
 
        template<typename T>
        void drawCurves(const SequenceTrack& track, const SequenceTrackSegment& segment, const ImVec2& trackTopLeft, float previousSegmentX, float segmentWidth, float segmentX, ImDrawList* drawList);
 
        template<typename T>
        void drawTanHandler(const SequenceTrack& track,
                            const SequenceTrackSegment& segment,
                            std::ostringstream& stringStream,
                            float segmentWidth,
                            const math::FCurvePoint<float, float>& curvePoint,
                            const ImVec2& circlePoint, int controlPointIndex,
                            int curveIndex,
                            sequencecurveenums::ETanPointTypes type,
                            ImDrawList* drawList);
 
        void handleInsertSegmentPopup();
 
        void handleEditSegmentPopup();
 
        void handleInsertCurvePointPopup();
 
        template<typename T>
        void handleCurvePointActionPopup();
 
        template<typename T>
        void handleSegmentValueActionPopup();
 
        template<typename T>
        void handleChangeMinMaxCurve();
 
        void handleDragTanPoint();
 
        void handleAssignOutputIDToTrack();
 
        void handleDragSegmentHandler();
 
        void handleCurveTypePopup();
 
        void handleTanPointActionPopup();
 
        void handleDraggingSegmentValue();
 
        void handleDraggingControlPoints();
 
        void handleLoadPresetPopup();
 
        template<typename T>
        void drawInspectorRange(const SequenceTrack& track);
 
        template<typename T>
        void showValue(const SequenceTrack& track, const SequenceTrackSegmentCurve<T>& segment, float x, double time, int curveIndex);
 
        template<typename T>
        bool inputFloat(T&, int precision);
 
        void showInspectorContent(const SequenceTrack& track) override;
 
        void showTrackContent(const SequenceTrack& track, const ImVec2& trackTopLeft) override;
 
        template<typename T>
        bool pasteClipboardSegments(const std::string& trackId, double time, utility::ErrorState& errorState);
 
        template<typename T>
        void pasteClipboardSegmentInto(const std::string& trackID, const std::string& segmentID);
 
        void updateSegmentInClipboard(const std::string& trackID, const std::string& segmentID);
 
        void updateSegmentsInClipboard(const std::string& trackID);
 
        // curve cache holds evaluated curves, needs to be cleared when view changes and curves need to be redrawn
        std::unordered_map<std::string, std::vector<std::vector<ImVec2>>> mCurveCache;
 
        // short curt to member function drawSegmentContent
        using DrawSegmentMemFunPtr = void (SequenceCurveTrackView::*)(const SequenceTrack &track, const SequenceTrackSegment &segment, const ImVec2 &trackTopLeft, float previousSegmentX, float segmentWidth, float segmentX, ImDrawList *drawList, bool drawStartValue);
 
        // static map of member function pointers
        static std::unordered_map<rttr::type, DrawSegmentMemFunPtr> &getDrawCurveSegmentsMap();
    };
 
    // Curve Clipboards
 
    namespace sequenceguiclipboard
    {
        class NAPAPI CurveSegmentClipboard final : public Clipboard
        {
        RTTI_ENABLE(Clipboard)
        public:
            CurveSegmentClipboard(const rttr::type &segmentType, std::string trackID, std::string sequenceName)
                : Clipboard(segmentType), mTrackID(std::move(trackID)), mSequenceName(std::move(sequenceName))
            {}
 
 
            void changeTrackID(const std::string &newTrackID);
 
 
            const std::string& getTrackID() const{ return mTrackID; }
 
 
            const std::string& getSequenceName() const { return mSequenceName; }
 
 
        private:
            std::string mTrackID;
            std::string mSequenceName;
        };
    }
 
 
    // Forward declarations
 
    template<>
    void SequenceCurveTrackView::handleCurvePointActionPopup<float>();
 
    template<>
    void SequenceCurveTrackView::handleSegmentValueActionPopup<float>();
 
    template<>
    void SequenceCurveTrackView::showValue<float>(const SequenceTrack& track,
                                                  const SequenceTrackSegmentCurve<float>& segment, float x, double time,
                                                  int curveIndex);
 
    template<>
    void SequenceCurveTrackView::showValue<glm::vec2>(const SequenceTrack& track, const SequenceTrackSegmentCurve<glm::vec2>& segment, float x, double time, int curveIndex);
 
    template<>
    void SequenceCurveTrackView::showValue<glm::vec3>(const SequenceTrack& track, const SequenceTrackSegmentCurve<glm::vec3>& segment, float x, double time, int curveIndex);
 
    template<>
    void SequenceCurveTrackView::showValue<glm::vec4>(const SequenceTrack& track, const SequenceTrackSegmentCurve<glm::vec4>& segment, float x, double time, int curveIndex);
 
    template<>
    bool SequenceCurveTrackView::inputFloat<float>(float& v, int precision);
 
    template<>
    bool SequenceCurveTrackView::inputFloat<glm::vec2>(glm::vec2& v, int precision);
 
    template<>
    bool SequenceCurveTrackView::inputFloat<glm::vec3>(glm::vec3& v, int precision);
 
    template<>
    bool SequenceCurveTrackView::inputFloat<glm::vec4>(glm::vec4& v, int precision);
}
 
// Include all template definitions
#include "sequencecurvetrackview_template.h"