sequenceguiservice.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
 
// External Includes
#include <nap/service.h>
#include <entity.h>
#include <nap/datetime.h>
#include <rtti/factory.h>
#include <imguiservice.h>
 
namespace nap
{
 
    // forward declares
    class SequenceEventTrackSegmentViewBase;
    class SequenceEventTrackView;
    class SequenceTrackSegmentEventBase;
    class SequenceTrackView;
    class SequenceGUIService;
    class SequenceEditorGUIView;
    class SequenceEditorGUIState;
 
    // shortcuts
    using SequenceEventTrackSegmentViewFactoryFunc = std::function<std::unique_ptr<SequenceEventTrackSegmentViewBase>()>;
    using SequenceEventTrackSegmentViewFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceEventTrackSegmentViewFactoryFunc>;
    using SequenceTrackViewFactoryFunc = std::function<std::unique_ptr<SequenceTrackView>(SequenceGUIService &, SequenceEditorGUIView &, SequenceEditorGUIState &)>;
    using SequenceTrackViewFactoryMap = std::unordered_map<rtti::TypeInfo, SequenceTrackViewFactoryFunc>;
    using SequenceTrackTypeForViewTypeMap = std::unordered_map<rtti::TypeInfo, rtti::TypeInfo>;
    using SequenceEventTrackPasteFunc = std::function<void(SequenceEventTrackView &, const std::string &, const SequenceTrackSegmentEventBase &, double)>;
    using SequenceEventTrackEditFunc = std::function<void(SequenceEventTrackView &)>;
 
    namespace icon
    {
        namespace sequencer
        {
            inline constexpr const char *play       = "seq_play.png";
            inline constexpr const char *stop       = "seq_stop.png";
            inline constexpr const char *rewind     = "seq_replay.png";
            inline constexpr const char *up         = "seq_up-arrow.png";
            inline constexpr const char *down       = "seq_down-arrow.png";
            inline constexpr const char *pause      = "seq_pause.png";
            inline constexpr const char *unpause    = "seq_unpause.png";
            inline constexpr const char *lock       = "seq_lock.png";
            inline constexpr const char *undo       = "seq_undo.png";
            inline constexpr const char *redo       = "seq_redo.png";
            inline constexpr const char *history    = "seq_history.png";
        }
    }
 
    class NAPAPI SequenceGUIService final : public Service
    {
        friend class SequencePlayerOutput;
 
    RTTI_ENABLE(Service)
    public:
 
        struct Colors
        {
            void init(const gui::ColorPalette& palette);
 
            ImU32 mHigh1 = 0;        
            ImU32 mHigh2 = 0;        
            ImU32 mHigh3 = 0;        
            ImU32 mHigh4 = 0;        
            ImU32 mDark = 0;        
            ImU32 mBack = 0;        
            ImU32 mFro1 = 0;        
            ImU32 mFro2 = 0;        
            ImU32 mFro3 = 0;        
            ImU32 mFro4 = 0;        
 
            ImU32 mCurveColors[4] = {4285098440, 4278255360, 4294901760, 4278255615};
        };
 
        SequenceGUIService(ServiceConfiguration* configuration);
 
        ~SequenceGUIService() override;
 
        static bool registerObjectCreator(std::unique_ptr<rtti::IObjectCreator>(* objectCreator)(SequenceGUIService*));
 
        template<typename T>
        bool registerEventView();
 
        bool registerTrackViewFactory(rtti::TypeInfo trackType, SequenceTrackViewFactoryFunc factory);
 
        bool registerTrackTypeForView(rtti::TypeInfo trackType, rtti::TypeInfo viewType);
 
        std::unique_ptr<SequenceTrackView> invokeTrackViewFactory(rtti::TypeInfo viewType, SequenceEditorGUIView& view, SequenceEditorGUIState& state);
 
        std::unique_ptr<SequenceEventTrackSegmentViewBase> invokeEventTrackSegmentViewFactory(rtti::TypeInfo eventType);
 
        rtti::TypeInfo getViewTypeForTrackType(rtti::TypeInfo trackType) const;
 
        const std::vector<rtti::TypeInfo>& getRegisteredSegmentEventTypes() const;
 
        void invokeEditEventHandler(rtti::TypeInfo actionType, SequenceEventTrackView& view) const;
 
 
        void invokePasteEvent(rtti::TypeInfo eventType, SequenceEventTrackView& view, const std::string& trackID,
                              const SequenceTrackSegmentEventBase& eventBase, double time) const;
 
        std::vector<rtti::TypeInfo> getAllTrackTypes() const;
 
        std::vector<rtti::TypeInfo> getAllRegisteredEventActions() const;
 
        nap::IMGuiService& getGui();
 
        const nap::IMGuiService& getGui() const;
 
 
        const Colors &getColors() const{ return mColors; }
 
    protected:
        void registerObjectCreators(rtti::Factory& factory) override;
 
        bool init(nap::utility::ErrorState& errorState) override;
 
        virtual void getDependentServices(std::vector<rtti::TypeInfo>& dependencies);
 
    private:
        // map of segment view types
        SequenceEventTrackSegmentViewFactoryMap mEventSegmentViewFactoryMap;
 
        // map of view factory functions
        SequenceTrackViewFactoryMap mTrackViewFactoryMap;
 
        // map of segment edit event handlers
        std::unordered_map<rtti::TypeInfo, SequenceEventTrackEditFunc> mEditEventHandlerMap;
 
        // map of segment paste handlers
        std::unordered_map<rtti::TypeInfo, SequenceEventTrackPasteFunc> mPasteEventMap;
 
        // list of event types
        std::vector<rtti::TypeInfo> mSegmentEventTypes;
 
        // which view type belongs to which track type
        SequenceTrackTypeForViewTypeMap mTrackViewTypeMap;
 
        // Link to the gui service
        IMGuiService* mGuiService = nullptr;
 
        // Colors
        Colors mColors;
    };
}