Visual.h

Go to the documentation of this file.

#pragma once

#include <iostream>
#include <utility>
#include <optional>
#include <limits>
#include "Callbacks.h"
#include "StructuredTypes.h"
#include "Types.h"
#include "Utilities.h"
#include "Texture.h"

namespace rose {

    namespace gm {
        class Context;
    }

    class Widget;
    class Window;
    class Manager;
    class Widget;

    struct State {
        std::string_view stateString;
    };

    struct SemanticGesture {
        uint32_t value;
        static SemanticGesture None;
        static SemanticGesture Click;
        static SemanticGesture Drag;
        static SemanticGesture Scroll;
        static SemanticGesture Key;
        static SemanticGesture Multi;

        [[nodiscard]] bool supports(SemanticGesture semanticGesture) const {
            return (value & semanticGesture.value) != 0;
        }

        SemanticGesture operator|(const SemanticGesture& other) const {
            SemanticGesture result{};
            result.value = value | other.value;
            return result;
        }
    };

    class LayoutHint {
        friend class Visual;

    public:
        static constexpr size_t AttachmentHint = 0;
        static constexpr size_t GridHint = 1;

        enum class GridLayoutHint : int {
            EndStride,
            AxisSize,
            AxisOffset,
        };

        enum class Attachment : int {
            None,           
            TopLeft,        
            TopRight,       
            BottomLeft,     
            BottomRight,    
            Top,            
            Left,           
            TopTo,          
            LeftTo,         
            Bottom,         
            Right,          
            BottomTo,       
            RightTo,        
            TopWith,        
            LeftWith,       
            BottomWith,     
            RightWith,      
        };

        static constexpr int RefIndexNone = std::numeric_limits<int>::max();

    protected:
        size_t mHintClass;
        int mValueType;
        int mValue;

    public:
        LayoutHint() = delete;

        LayoutHint(Attachment attachment, int index) {
            mHintClass = AttachmentHint;
            mValueType = static_cast<int>(attachment);
            mValue = index;
        }

        LayoutHint(GridLayoutHint hint, int value) {
            mHintClass = GridHint;
            mValueType = static_cast<int>(hint);
            mValue = value;
        }
    };

    class Visual {
    public:
        friend class LayoutManager;

        using ValueMap = std::map<int, int>;        
        std::map<size_t, ValueMap> mHintsMap{};     

    protected:
        SemanticGesture mSemanticGesture{};
        Position<int> mPos{};            
        Size mSize{};               
        Position<int> mPreferredPos{};   
        Size mPreferredSize{};      
        Rectangle mScreenRect{};    
        Padding mPadding{};         
        State mState{};             
        bool mVisible{true};        

    public:
        void setScreenRectangle(const Position<int> &containerPosition) {
            mScreenRect = getScreenRectangle(containerPosition);
        }

        [[nodiscard]] Rectangle getScreenRectangle(const Position<int> &containerPosition) const {
            return Rectangle{containerPosition + mPos, mSize};
        }

        virtual void draw(gm::Context &context, const Position<int> &containerPosition) = 0;

        virtual Rectangle layout(rose::gm::Context &context, const Rectangle &screenRect) = 0;

        Position<int> drawPadding(const Position<int> &containerPosition) {
            return containerPosition + mPadding.position();
        }

        Rectangle layoutPadding(const Rectangle &screenRect) {
            return Rectangle{screenRect.position(), screenRect.size() + mPadding.size()};
        }

        void setSize(const Size& size) {
            mPreferredSize = size;
        }

        [[nodiscard]] Size getSize() const {
            return mPreferredSize;
        }

        void setPosition(const Position<int>& position) {
            mPreferredPos = position;
        }

        [[nodiscard]] Position<int> getPosition() const {
            return mPreferredPos;
        }

        void setPadding(const Padding &padding) {
            mPadding = padding;
        }

        void setScreenRectangle(const Rectangle &screenRect) {
            mPos = screenRect.position();
            mSize = screenRect.size();
        }

        [[nodiscard]] constexpr bool isVisible() const noexcept {
            return mVisible;
        }

        void setVisible(bool visible) noexcept {
            mVisible = visible;
        }

        void setLayoutHint(const LayoutHint &hint) {
            mHintsMap[hint.mHintClass][hint.mValueType] = hint.mValue;
        }

        std::optional<int> getAttachmentHint(LayoutHint::Attachment attachment) {
            if (auto map = mHintsMap.find(LayoutHint::AttachmentHint); map != mHintsMap.end()) {
                if (auto att = (*map).second.find(static_cast<int>(attachment)); att != (*map).second.end()) {
                    return (*att).second;
                }
            }
            return std::nullopt;
        }

        std::optional<int> getGridHint(LayoutHint::GridLayoutHint gridLayoutHint) {
            if (auto map = mHintsMap.find(LayoutHint::GridHint); map != mHintsMap.end()) {
                if (auto gridHint = (*map).second.find(static_cast<int>(gridLayoutHint)); gridHint != (*map).second.end()) {
                    return (*gridHint).second;
                }
            }
            return std::nullopt;
        }

        template<size_t HintClass>
        [[nodiscard]] std::optional<const ValueMap> getHintMap() const {
            static_assert(HintClass == LayoutHint::AttachmentHint || HintClass == LayoutHint::GridHint,
                    "Supported maps are: LayoutHint::AttachmentHint, LayoutHint::GridHint.");
            if (auto map = mHintsMap.find(HintClass); map != mHintsMap.end()) {
                return std::make_optional<const ValueMap>((*map).second);
            }
            return std::nullopt;
        }

        [[nodiscard]] SemanticGesture supportedSemanticGestures() const { return mSemanticGesture; }
    };

    class Application;

    class Screen : public Visual, public Container {
        Application& mApplication;

    public:
        explicit Screen(Application &application);
        ~Screen() override = default;

        static constexpr std::string_view id = "Screen";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void add(const std::shared_ptr<Node> &node) override {
            if (auto window = std::dynamic_pointer_cast<Window>(node); window)
                Container::add(node);
            else
                throw NodeTypeError("A Screen may only contain Window objects.");
        }

        void draw(gm::Context &context, const Position<int> &containerPosition) override;

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;

        Application& getApplication() {
            return mApplication;
        }

        const Application& getApplication() const {
            return mApplication;
        }
    };

    class Window : public Visual, public Container {
    protected:
        bool mModalWindow{};
        gm::Texture mBaseTexture{};     

    public:
        ~Window() override = default;

        static constexpr std::string_view id = "Window";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        bool isModal() const { return mModalWindow; }

        void add(const std::shared_ptr<Node> &node) override {
            if (empty()) {
                if (std::dynamic_pointer_cast<Manager>(node))
                    Container::add(node);
                else
                    throw NodeTypeError("A Window may only contain one Manager object.");
            } else {
                throw NodeRangeError("A Window may only contain one Manager object.");
            }
        }

        void draw(gm::Context &context, const Position<int> &containerPosition) override;

        bool baseTextureNeeded(const Position<int> &containerPosition) {
            setScreenRectangle(containerPosition);
            return !mBaseTexture || mBaseTexture.getSize() != mScreenRect.size();
        }
        void generateBaseTexture(gm::Context &context, const Position<int> &containerPosition);

        void drawBaseTexture(gm::Context &context, const Position<int> &containerPosition);

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;

        std::shared_ptr<Widget> pointerWidget(const Position<int>& position);

        std::shared_ptr<Screen> getScreen() {
            if (auto screen = std::dynamic_pointer_cast<Screen>(container()))
                return screen;
            return nullptr;
        }

        std::shared_ptr<Screen> getScreen() const {
            if (auto screen = std::dynamic_pointer_cast<Screen>(container()))
                return screen;
            return nullptr;
        }
    };

    class LayoutManager {
    protected:
        size_t mMaxContent{UnlimitedContent};   //The maximum number of objects the LayoutManager supports.

        static Rectangle getScreenRectangle(std::shared_ptr<Visual> &visual) {
            return Rectangle{visual->mPos, visual->mSize};
        }

    public:
        static constexpr size_t UnlimitedContent = std::numeric_limits<size_t>::max();

        virtual ~LayoutManager() = default;
        using Itr = Container::iterator;

        virtual Rectangle layoutContent(gm::Context &context, const Rectangle &screenRect, LayoutManager::Itr first,
                                        LayoutManager::Itr last) = 0;

        [[nodiscard]] size_t maximumContent() const { return mMaxContent; }
    };

    template<class Layout, typename ... Args>
    std::unique_ptr<Layout> makeLayout(Args ... args) {
        static_assert(std::is_base_of_v<LayoutManager, Layout>, "Layout must be derived from LayoutManager.");
        return std::make_unique<Layout>(args ...);
    }

    class SimpleLayout : public LayoutManager {
    public:
        ~SimpleLayout() override = default;

        Rectangle layoutContent(gm::Context &context, const Rectangle &screenRect, LayoutManager::Itr first,
                                LayoutManager::Itr last) override;
    };

    class LayoutManagerError : public std::runtime_error {
    public:
        LayoutManagerError() = delete;
        explicit LayoutManagerError(const std::string &what) : std::runtime_error(what) {}
        explicit LayoutManagerError(const char *what) : std::runtime_error(what) {}
        LayoutManagerError(const LayoutManagerError& other) = default;
    };

    class Widget : public Visual, public Container {
    protected:
        EventCallback mEnterEventCallback{};

        EventCallback mLeaveEventCallback{};

        ButtonCallback mButtonEventCallback{};

        MouseMotionCallback mMouseMotionCallback{};

        ScrollCallback mMouseScrollCallback{};

        KeyboardShortcutCallback mKeyboardShortcutCallback{};

        TextInputCallback mTextInputCallback{};

        KeyboardFocusCallback mKeyboardFocusCallback{};

        KeyboardEventCallback mKeyboardEventCallback{};

    public:
        Widget() = default;

        ~Widget() override = default;

        Widget(const Widget &) = delete;

        Widget(Widget &&) = delete;

        Widget &operator=(const Widget &) = delete;

        Widget &operator=(Widget &&) = delete;

        static constexpr std::string_view id = "Widget";
        std::string_view nodeId() const noexcept override {
            return id;
        }

//        std::shared_ptr<Widget> focusWidget(SemanticGesture gesture, Position position, Position containerPosition);

        std::shared_ptr<Widget> pointerWidget(const Position<int>& position, const Position<int>& containerPosition);

        Position<int> computeScreenPosition();

        bool contains(const Position<int> &position);

//        void clearFocus(const SemanticGesture &gesture) {}

        Application& getApplication() {
            if (auto window = getWindow(); window) {
                if (auto screen = window->getScreen(); screen)
                    return screen->getApplication();
            }
            throw std::runtime_error("No path from Widget to Screen to Application.");
        }

        Application& getApplication() const {
            if (auto window = getWindow(); window) {
                if (auto screen = window->getScreen(); screen)
                    return screen->getApplication();
            }
            throw std::runtime_error("No path from Widget to Screen to Application.");
        }

        std::shared_ptr<Window> getWindow() {
            auto c = container();
            while (c) {
                if (auto window = std::dynamic_pointer_cast<Window>(c); window)
                    return window;
                c = c->container();
            }

            return nullptr;
        }

        std::shared_ptr<Window> getWindow() const {
            auto c = container();
            while (c) {
                if (auto window = std::dynamic_pointer_cast<Window>(c); window)
                    return window;
                c = c->container();
            }

            return nullptr;
        }

        bool enterEvent() {
            if (mEnterEventCallback)
                return mEnterEventCallback();
            return false;
        }

        void setEnterLeaveEventCallback(EventCallback eventCallback) {
            mEnterEventCallback = std::move(eventCallback);
        }

        bool leaveEvent() {
            if (mLeaveEventCallback)
                return mLeaveEventCallback();
            return false;
        }

        void setLeaveEventCallback(EventCallback eventCallback) {
            mLeaveEventCallback = std::move(eventCallback);
        }

        bool buttonEvent(bool pressed, uint button, uint clicks, bool passed);

        void setButtonEventCallback(ButtonCallback buttonCallback) {
            mButtonEventCallback = std::move(buttonCallback);
        }

        bool mouseMotionEvent(bool pressed, uint button, const Position<int>& mousePos, const Position<int>& relativePos, bool passed);

        void setMouseMotionEventCallback(MouseMotionCallback mouseMotionCallback) {
            mMouseMotionCallback = std::move(mouseMotionCallback);
        }

        bool mouseScrollEvent(const Position<int>& deltaPos, bool passed);

        void setMouseScrollEventCallback(ScrollCallback scrollCallback) {
            mMouseScrollCallback = std::move(scrollCallback);
        }

        bool keyboardShortcutEvent(uint32_t shortcutCode, bool state, uint repeat);

        void setKeyboardShortcutCallback(KeyboardShortcutCallback keyboardShortcutCallback) {
            mKeyboardShortcutCallback = std::move(keyboardShortcutCallback);
        }

        bool keyTextInputEvent(const std::string& text);

        void setTextInputCallback(TextInputCallback textInputCallback) {
            mTextInputCallback = std::move(textInputCallback);
        }

        bool supportsKeyboardFocus() const {
            if (mTextInputCallback || mKeyboardFocusCallback || mKeyboardEventCallback)
                return true;
            return false;
        }

        bool keyboardFocusEvent(bool hasFocus);

        void setKeyboardFocusCallback(KeyboardFocusCallback keyboardFocusCallback) {
            mKeyboardFocusCallback = std::move(keyboardFocusCallback);
        }

        bool keyboardEvent(const SDL_KeyboardEvent &keyboardEvent);

        void setKeyboardEvent(KeyboardEventCallback keyboardEventCallback) {
            mKeyboardEventCallback = keyboardEventCallback;
        }
    };

    class Manager : public Widget {
    protected:
        std::unique_ptr<LayoutManager> mLayoutManager{};

    public:
        Manager();

        ~Manager() override = default;

        Manager(const Manager&) = delete;

        Manager(Manager&&) = delete;

        Manager& operator=(const Manager&) = delete;

        Manager& operator=(Manager&&) = delete;

        static constexpr std::string_view id = "Manager";
        std::string_view nodeId() const noexcept override {
            return id;
        }

        void add(const std::shared_ptr<Node> &node) override {
            if (mLayoutManager) {
                if (mLayoutManager->maximumContent() == LayoutManager::UnlimitedContent || size() < mLayoutManager->maximumContent()) {
                    if (std::dynamic_pointer_cast<Widget>(node) || std::dynamic_pointer_cast<Manager>(node))
                        Container::add(node);
                    else
                        throw NodeTypeError("A Manager may only contain Manager or Widget objects.");
                } else {
                    throw NodeRangeError(StringCompositor("Contents exceed maximum limit: ",
                                                          mLayoutManager->maximumContent()));
                }
            } else {
                throw LayoutManagerError("Can not add content without a LayoutManager.");
            }
        }

        void draw(gm::Context &context, const Position<int> &containerPosition) override;

        Rectangle layout(gm::Context &context, const Rectangle &screenRect) override;

        void setLayoutManager(std::unique_ptr<LayoutManager> &&layoutManager) {
            mLayoutManager = std::move(layoutManager);
        }

        std::unique_ptr<LayoutManager>& layoutManager() { return mLayoutManager; }
    };

    struct Parent {};

    static Parent endw{};

    template<class WidgetClass, typename ... Args>
    inline std::shared_ptr<WidgetClass> wdg(Args ... args) {
        return std::make_shared<WidgetClass>(args ...);
    }
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator >>(std::shared_ptr<WidgetClass> widget, std::shared_ptr<rose::Widget> &store) {
    static_assert(std::is_base_of_v<rose::Widget,WidgetClass>, "WidgetClass must be derived from rose::Widget." );
    store = widget;
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator >>(std::shared_ptr<WidgetClass> widget, std::shared_ptr<WidgetClass> &store) {
    static_assert(std::is_base_of_v<rose::Widget,WidgetClass>, "WidgetClass must be derived from rose::Widget." );
    store = widget;
    return widget;
}

//template<class ManagerClass>
//inline std::shared_ptr<ManagerClass> operator >>(std::shared_ptr<ManagerClass> manager, std::shared_ptr<rose::Manager> &store) {
//    static_assert(std::is_base_of_v<rose::Manager,ManagerClass>, "ManagerClass must be derived from rose::Manager." );
//    store = manager;
//    return manager;
//}

template<class WidgetClass>
inline std::shared_ptr<rose::Manager> operator<<(std::shared_ptr<WidgetClass> widget, const rose::Parent &) {
    static_assert(std::is_base_of_v<rose::Widget, WidgetClass> || std::is_base_of_v<rose::Manager, WidgetClass>,
                  "WidgetClass must be derived from rose::Widget or rose::Manager.");
    return std::dynamic_pointer_cast<rose::Manager>(widget->container());
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const rose::Size& size) {
    static_assert(std::is_base_of_v<rose::Widget, WidgetClass> || std::is_base_of_v<rose::Manager, WidgetClass>,
            "WidgetClass must be derived from rose::Widget or rose::Manager.");
    widget->setSize(size);
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const rose::Position<int>& position) {
    static_assert(std::is_base_of_v<rose::Widget, WidgetClass> || std::is_base_of_v<rose::Manager, WidgetClass>,
                  "WidgetClass must be derived from rose::Widget or rose::Manager.");
    widget->setPosition(position);
    return widget;
}

template<class ContainerClass, class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<ContainerClass> container, std::shared_ptr<WidgetClass> widget) {
    static_assert(std::is_base_of_v<rose::Visual, ContainerClass> && std::is_base_of_v<rose::Container, ContainerClass>,
                  "ContainerClass must be derived from both rose::Visual and rose::Container.");
    static_assert(std::is_base_of_v<rose::Visual, WidgetClass> && std::is_base_of_v<rose::Node, WidgetClass>,
                  "WidgetClass must be derived from both rose::visual and rose::Node.");
    container->add(widget);
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, std::unique_ptr<rose::LayoutManager>&& layout) {
    static_assert(std::is_base_of_v<rose::Manager,WidgetClass>, "WidgetClass must be derived from rose::Manager.");
    widget->setLayoutManager(std::move(layout));
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const rose::Padding& padding) {
    static_assert(std::is_base_of_v<rose::Visual, WidgetClass>, "WidgetClass must be derived from rose::Visual.");
    widget->setPadding(padding);
    return widget;
}

template<class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const rose::LayoutHint& hint) {
    static_assert(std::is_base_of_v<rose::Visual, WidgetClass>, "WidgetClass must be derived from rose::Visual.");
    widget->setLayoutHint(hint);
    return widget;
}