dxlib_gui_updater.h

[詳解]

 
 
// Copyright(c) 2023-2025 Design Engineering Laboratory, Saitama University
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
 
#ifndef DESIGNLAB_DXLIB_GUI_UPDATER_H_
#define DESIGNLAB_DXLIB_GUI_UPDATER_H_
 
#include <map>
#include <memory>
#include <optional>
 
#include "cassert_define.h"
#include "interface_dxlib_clickable.h"
#include "interface_dxlib_draggable.h"
#include "interface_dxlib_gui.h"
#include "interface_dxlib_wheel_handler.h"
#include "mouse.h"
 
 
namespace designlab
{
 
template <typename T>
concept IsDxlibGui = std::is_base_of<IDxlibGui, T>::value;
 
template <typename T>
concept IsDxlibClickable = std::is_base_of<IDxlibClickable, T>::value;
 
template <typename T>
concept IsDxlibDraggable = std::is_base_of<IDxlibDraggable, T>::value;
 
template <typename T>
concept IsDxlibWheelHandler = std::is_base_of<IDxlibWheelHandler, T>::value;
 
template <typename T>
concept IsDxlibUpdatable = (IsDxlibGui<T> || IsDxlibClickable<T> ||
    IsDxlibDraggable<T> || IsDxlibWheelHandler<T>);
 
 
class DxlibGuiUpdater final
{
public:
    static constexpr int kBottomPriority{ 0 };      
    static constexpr int kTopPriority{ 1000000 };   
 
    template <IsDxlibUpdatable T>
    void Register(const std::shared_ptr<T>& gui_ptr, int priority)
    {
        assert(kBottomPriority <= priority);
        assert(priority <= kTopPriority);
 
        if constexpr (IsDxlibGui<T>)
        {
            RegisterGui(gui_ptr, priority);
        }
        if constexpr (IsDxlibClickable<T>)
        {
            RegisterClickable(gui_ptr, priority);
        }
        if constexpr (IsDxlibDraggable<T>)
        {
            RegisterDraggable(gui_ptr, priority);
        }
        if constexpr (IsDxlibWheelHandler<T>)
        {
            RegisterWheelHandler(gui_ptr, priority);
        }
    }
 
    void OpenTerminal();
 
    void Activate(const std::shared_ptr<const Mouse>& mouse_ptr);
 
    void Draw() const;
 
private:
    struct Priority final
    {
        constexpr Priority(const int p, const int o) noexcept :
            priority(p),
            order(o)
        {
        }
 
        bool operator<(const Priority& other) const noexcept
        {
            if (priority == other.priority)
            {
                return order < other.order;
            }
            else
            {
                return priority < other.priority;
            }
        }
 
        int priority{ 0 };  
        int order{ 0 };     
    };
 
    void RegisterGui(const std::shared_ptr<IDxlibGui> gui_ptr, int priority);
    void RegisterClickable(
        const std::shared_ptr<IDxlibClickable> clickable_ptr, int priority);
    void RegisterDraggable(
        const std::shared_ptr<IDxlibDraggable> draggable_ptr, int priority);
    void RegisterWheelHandler(
        const std::shared_ptr<IDxlibWheelHandler> wheel_handler_ptr, int priority);
 
    void UpdateGui();
 
    void ActivateClickable(const std::shared_ptr<const Mouse> mouse_ptr);
    void ActivateDraggable(const std::shared_ptr<const Mouse> mouse_ptr);
    void ActivateWheelHandler(const std::shared_ptr<const Mouse> mouse_ptr);
 
    std::map<Priority, std::shared_ptr<IDxlibGui> > gui_ptrs_;
    std::map<Priority, std::shared_ptr<IDxlibClickable> > clickable_ptrs_;
    std::map<Priority, std::shared_ptr<IDxlibDraggable> > draggable_ptrs_;
    std::map<Priority, std::shared_ptr<IDxlibWheelHandler> > wheel_handler_ptrs_;
 
    std::optional<Priority> now_dragging_gui_key_{ std::nullopt };
 
    bool is_terminal_opened_{ false };  
};
 
}  // namespace designlab
 
 
#endif  // DESIGNLAB_DXLIB_GUI_UPDATER_H_