mgl_ui_widget.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_UI_WIDGET_H_1625439573
#define INCGUARD_MGL_UI_WIDGET_H_1625439573
 
#include <mgl/common/mgl_alignment.h>
#include <mgl/input/touch/mgl_touch_state.h>
#include <mgl/mgl_environment.h>
#include <mgl/stl/mgl_stl_containers.h>
#include <mgl/ui/mgl_ui_event_delegate.h>
#include <mgl/ui/mgl_ui_event_listener.h>
 
namespace MGL::UI
{
class EventContext;
class EventListener;
class EventDelegate;
 
class Widget
{
public:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    Widget(uint32_t typeIdentifier) noexcept
        : _typeIdentifier(typeIdentifier)
    {
    }
 
    virtual ~Widget() noexcept = default;
 
    void Update(const MGL::Vector2 &offset = MGL::Vector2(0.0f, 0.0f), bool updateEvent = true) noexcept;
    void Render(const MGL::Vector2 &offset = MGL::Vector2(0.0f, 0.0f)) noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void Update(bool updateEvent) noexcept
    {
        Update(MGL::Vector2(), updateEvent);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] virtual MGL::Rectangle GetRectangle() const noexcept = 0;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr uint32_t GetTypeIdentifier() const noexcept
    {
        return _typeIdentifier;
    }
 
    void SetVisible(bool isVisible) noexcept;
    [[nodiscard]] bool IsVisible() const noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool GetLocalVisibleFlag() const noexcept
    {
        return _isVisible;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetTransparency(float transparency) noexcept
    {
        _transparency = transparency;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr float GetLocalTransparency() const noexcept
    {
        return _transparency;
    }
 
    [[nodiscard]] float GetTransparency() const noexcept;
 
    [[nodiscard]] MGL::Vector2 GetPosition() const noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr MGL::Vector2 GetSize() const noexcept
    {
        return GetRectangle().GetSize();
    }
 
    [[nodiscard]] MGL::Vector2 GetParentSize() const noexcept;
 
    bool AddChild(Widget *child) noexcept;
    bool RemoveChild(Widget *child) noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] const Widget *GetParent() const noexcept
    {
        return _parent;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] const MGL::STL::list<Widget *> &GetChildren() const noexcept
    {
        return _children;
    }
 
    bool ActivateEventContext(EventListener *listener, EventDelegate *delegate) noexcept;
    bool ActivateEventContext(EventListener *listener) noexcept;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetEventIdentifier(EventID identifier) noexcept
    {
        _eventIdentifier = identifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr EventID GetEventIdentifier() const noexcept
    {
        return _eventIdentifier;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetPivot(const MGL::Alignment &pivotAlignment) noexcept
    {
        _pivotAlignment = pivotAlignment;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const MGL::Alignment &GetPivot() const noexcept
    {
        return _pivotAlignment;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetAnchor(const MGL::Alignment &anchorAlignment) noexcept
    {
        _anchorAlignment = anchorAlignment;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const MGL::Alignment &GetAnchor() const noexcept
    {
        return _anchorAlignment;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr EventState GetEventState() const noexcept
    {
        return _eventState;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr MGL::Input::TouchID GetEventTouchID() const noexcept
    {
        return _eventTouchID;
    }
 
protected:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnUpdate(const MGL::Vector2 &position) noexcept
    {
        (void)position;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnRender(const MGL::Vector2 &position) noexcept
    {
        (void)position;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    virtual void OnNotifiedEvent(EventType eventType, uint32_t argument) noexcept
    {
        (void)eventType;
        (void)argument;
    }
 
private:
    void UpdateEvent(EventContext *eventContext, const MGL::Vector2 &offset) noexcept;
    void ApplyEventResult(EventContext *eventContext, const EventResult &result) noexcept;
    void SendEvent(EventContext *eventContext, EventType eventType, uint32_t argument = 0, MGL::Input::TouchID touchID = MGL::Input::TouchID::Invalid) noexcept;
 
    [[nodiscard]] MGL::Vector2 GetAdjustedPosition() const noexcept;
 
    uint32_t _typeIdentifier;
 
    Widget *_parent{nullptr};
    MGL::STL::list<Widget *> _children;
 
    bool _isVisible{true};
    float _transparency{1.0f};
 
    MGL::STL::unique_ptr<EventContext> _eventContext{nullptr};
    EventState _eventState{EventState::None};
    EventID _eventIdentifier{kInvalidEventID};
    MGL::Input::TouchID _eventTouchID{MGL::Input::TouchID::Invalid};
 
    MGL::Alignment _pivotAlignment;
    MGL::Alignment _anchorAlignment;
};
 
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template<typename Type>
class TypedWidget : public Widget
{
public:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    TypedWidget(Type type) noexcept
        : Widget(static_cast<uint32_t>(type))
    {
    }
 
    ~TypedWidget() noexcept override = default;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr Type GetType() const noexcept
    {
        return static_cast<Type>(GetTypeIdentifier());
    }
};
}    // namespace MGL::UI
 
#endif    // INCGUARD_MGL_UI_WIDGET_H_1625439573
 
// vim: et ts=4 sw=4 sts=4