spk_widget.hpp

#pragma once
 
#include <array>
#include <limits>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_inherence_object.hpp"
 
#include "structure/graphics/spk_extend_2d.hpp"
 
#include "structure/system/event/spk_keyboard_event.hpp"
#include "structure/system/event/spk_mouse_event.hpp"
#include "structure/system/event/spk_paint_event.hpp"
#include "structure/system/event/spk_system_event.hpp"
#include "structure/system/event/spk_update_event.hpp"
 
#include "structure/opengl/spk_view_region.hpp"
 
#include "structure/widget/spk_resizable_element.hpp"
 
#include "structure/graphics/spk_font.hpp"
#include "structure/graphics/spk_sprite_sheet.hpp"
 
#include "structure/graphics/painter/spk_texture_painter.hpp"
 
namespace spk
{
    namespace Module
    {
        class KeyboardModule;
        class MouseModule;
        class SystemModule;
        class UpdateModule;
        class PaintModule;
    }

    class Widget : public InherenceObject<Widget>, public ActivableObject, public ResizableElement
    {
    public:
        struct Style
        {
            static spk::SpriteSheet defaultNineSlice;
            static spk::SpriteSheet defaultPressedNineSlice;
            static spk::SpriteSheet defaultNineSliceLight;
            static spk::SpriteSheet defaultIconset;
            static spk::SpriteSheet defaultInterfaceWindowButtonReleased;
            static spk::SpriteSheet defaultInterfaceWindowButtonPressed;
            static spk::SpriteSheet defaultSliderBody;
            static spk::SpriteSheet defaultBreak;
            static spk::Font defaultFont;
            static spk::Font::Size defaultFontSize;
        };

        enum class FocusType
        {
            Keyboard = 0,
            Mouse = 1
        };

        static inline const size_t NbFocusType = 2;
 
    private:
        static inline std::array<Widget *, NbFocusType> _focusedWidgets = {nullptr, nullptr};
 
    public:
        static Widget *focusedWidget(FocusType p_focusType);

        void takeFocus(FocusType p_focusType);

        void releaseFocus(FocusType p_focusType);

        bool hasFocus(FocusType p_focusType) const;

        void takeAllFocus();

        void releaseAllFocus();
 
    private:
        template <typename TEvent>
        using EventHandler = void (Widget::*)(TEvent &);
 
        template <typename TEvent>
        void _propagateEvent(TEvent &p_event, EventHandler<TEvent> p_onEventHandler, EventHandler<TEvent> p_childHandler)
        {
            if (isActive() == false || p_event.isConsumed == true)
            {
                return;
            }
 
            for (auto child : children())
            {
                if (child != nullptr)
                {
                    (child->*p_childHandler)(p_event);
 
                    if (p_event.isConsumed == true)
                    {
                        break;
                    }
                }
            }
 
            if (p_event.isConsumed == true)
            {
                return;
            }
 
            (this->*p_onEventHandler)(p_event);
        }
 
    private:
        std::wstring _name;
 
        bool _isViewRegionUpdatePending = false;
        spk::Vector2 _anchorRatio = {0.0f, 0.0f};
        spk::Vector2 _sizeRatio = {1.0f, 1.0f};
        spk::OpenGL::ViewRegion _viewRegion;
        spk::Extend2D _geometry = {{0.0f, 0.0f}, {0.0f, 0.0f}};
 
        std::recursive_mutex _geometryEditionMutex;
 
        spk::OpenGL::FrameBufferObject _fbo;
 
        spk::TexturePainter _painter;
        spk::TextureMesh _fboMesh;
 
        float _layer = 0;
 
        void _computeRatio();
 
        void _sortChildByLayer();
 
        void _applyResize();
 
    public:
        Widget(const std::wstring &p_name, Widget *p_parent);
        ~Widget() override;

        void addChild(Widget *p_child) override;

        const float &layer() const;

        void setLayer(const float &p_newLayer);

        const std::wstring &name() const;

        void setName(const std::wstring &p_name);

        void setGeometry(const spk::Extend2D &p_geometry) override;

        const spk::Extend2D &geometry() const;

        const spk::OpenGL::ViewRegion &viewRegion() const;

        const spk::OpenGL::FrameBufferObject &frameBufferObject() const;
        const spk::OpenGL::FrameBufferObject &fbo() const;

        void requireGeometryChange();
 
    protected:
        virtual void _onPaintEvent(spk::PaintEvent &p_event);

        virtual void _onKeyPressEvent(spk::KeyPressEvent &p_event);

        virtual void _onKeyReleaseEvent(spk::KeyReleaseEvent &p_event);

        virtual void _onGlyphEvent(spk::GlyphEvent &p_event);

        virtual void _onMousePressEvent(spk::MousePressEvent &p_event);

        virtual void _onMouseReleaseEvent(spk::MouseReleaseEvent &p_event);

        virtual void _onMouseDoubleClickEvent(spk::MouseDoubleClickEvent &p_event);

        virtual void _onMouseMotionEvent(spk::MouseMotionEvent &p_event);

        virtual void _onMouseWheelEvent(spk::MouseWheelEvent &p_event);

        virtual void _onEnterResizeModeEvent(spk::EnterResizeModeEvent &p_event);

        virtual void _onResizeEvent(spk::ResizeEvent &p_event);

        virtual void _onExitResizeModeEvent(spk::ExitResizeModeEvent &p_event);

        virtual void _onQuitEvent(spk::QuitEvent &p_event);

        virtual void _onMoveEvent(spk::MoveEvent &p_event);

        virtual void _onFullScreenModeEvent(spk::FullScreenModeEvent &p_event);

        virtual void _onMaximizedModeEvent(spk::MaximizedModeEvent &p_event);

        virtual void _onFocusEvent(spk::FocusEvent &p_event);

        virtual void _onUpdateEvent(spk::UpdateEvent &p_event);

        virtual void _onGeometryChange();
 
    private:
        friend class Module::KeyboardModule;
        friend class Module::MouseModule;
        friend class Module::SystemModule;
        friend class Module::UpdateModule;
        friend class Module::PaintModule;
 
        void _handlePaintEvent(spk::PaintEvent &p_event);
 
        void _handleKeyPressEvent(spk::KeyPressEvent &p_event);
 
        void _handleKeyReleaseEvent(spk::KeyReleaseEvent &p_event);
 
        void _handleGlyphEvent(spk::GlyphEvent &p_event);
 
        void _handleMousePressEvent(spk::MousePressEvent &p_event);
 
        void _handleMouseReleaseEvent(spk::MouseReleaseEvent &p_event);
 
        void _handleMouseDoubleClickEvent(spk::MouseDoubleClickEvent &p_event);
 
        void _handleMouseMotionEvent(spk::MouseMotionEvent &p_event);
 
        void _handleMouseWheelEvent(spk::MouseWheelEvent &p_event);
 
        void _handleEnterResizeModeEvent(spk::EnterResizeModeEvent &p_event);
 
        void _handleResizeEvent(spk::ResizeEvent &p_event);
 
        void _handleExitResizeModeEvent(spk::ExitResizeModeEvent &p_event);
 
        void _handleQuitEvent(spk::QuitEvent &p_event);
 
        void _handleMoveEvent(spk::MoveEvent &p_event);
 
        void _handleFullScreenModeEvent(spk::FullScreenModeEvent &p_event);
 
        void _handleMaximizedModeEvent(spk::MaximizedModeEvent &p_event);
 
        void _handleFocusEvent(spk::FocusEvent &p_event);
 
        void _handleUpdateEvent(spk::UpdateEvent &p_event);
    };
}