UIUtility.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Function.hpp"
 
#include "CeresEngine/Math/Color.hpp"
#include "CeresEngine/Math/Rect.hpp"
 
namespace CeresEngine {
    class AnyInputEvent;
}
 
namespace CeresEngine {
    class UIView;
    class UIWindow;
    struct UIMouseEvent;
 
    using UIPoint = Point2;
 
    using UISize = Size2;
 
    using UIRect = Rect2;
 
    using UIEdgeInsets = Rect2Edge;
 
    struct UICornerRadius {
        double topLeft = 0.0;
        double topRight = 0.0;
        double bottomLeft = 0.0;
        double bottomRight = 0.0;
 
        friend bool operator==(const UICornerRadius& lhs, const UICornerRadius& rhs) {
            return lhs.topLeft == rhs.topLeft && lhs.topRight == rhs.topRight && lhs.bottomLeft == rhs.bottomLeft && lhs.bottomRight == rhs.bottomRight;
        }
        friend bool operator!=(const UICornerRadius& lhs, const UICornerRadius& rhs) { return !(rhs == lhs); }
    };
 
    enum class UITexturePosition {
        NoTexture,
 
        TextureOnly,
 
        TextureLeft,
 
        TextureRight,
 
        TextureBelow,
 
        TextureAbove,
 
        TextureOverlaps,
    };
 
    enum class UITextureScaling {
        None,
 
        ProportionallyDown,
 
        AxesIndependently,
 
        ProportionallyUpOrDown,
    };
 
    enum class UITextAlignment {
        Left,
 
        Right,
 
        Center,
 
        Justified,
    };
 
    template<typename View, typename Signature> class UIDelegate;
 
    template<typename View, typename R, typename... Args> class UIDelegate<View, R(Args...)> {
        friend View;
 
    private:
        using DelegateType = UniqueFunction<R(View&, Args...) const>;
        DelegateType mDelegate = nullptr;
 
    public:
        UIDelegate() = default;
        UIDelegate(const UIDelegate&) = default;
        UIDelegate& operator=(const UIDelegate&) = default;
 
        UIDelegate(UIDelegate&&) noexcept = default;
        UIDelegate& operator=(UIDelegate&&) noexcept = default;
 
        template<typename Delegate>
        CE_EXPLICIT(false) UIDelegate(Delegate&& delegate) // NOLINT
                : mDelegate(std::forward<Delegate>(delegate)) {}
 
        CE_EXPLICIT(false) UIDelegate(R&& value) // NOLINT
                : mDelegate([value = std::forward<R>(value)](View&, Args...) { return value; }) {}
 
    public:
        explicit operator bool() const noexcept { return mDelegate != nullptr; }
 
    private:
        R operator()(View* const view, Args... args) const {
            CE_ASSERT(view != nullptr);
            CE_ASSERT(mDelegate != nullptr);
            return mDelegate(*view, std::forward<Args>(args)...);
        }
    };
 
    template<typename View, typename... Args> class UIDelegate<View, void(Args...)> {
        friend View;
 
    private:
        using DelegateType = UniqueFunction<void(View&, Args...) const>;
        DelegateType mDelegate = nullptr;
 
    public:
        UIDelegate() = default;
        UIDelegate(const UIDelegate&) = default;
        UIDelegate& operator=(const UIDelegate&) = default;
 
        UIDelegate(UIDelegate&&) noexcept = default;
        UIDelegate& operator=(UIDelegate&&) noexcept = default;
 
        template<typename Delegate>
        CE_EXPLICIT(false) UIDelegate(Delegate&& delegate) // NOLINT
                : mDelegate(delegate) {}
 
    public:
        explicit operator bool() const noexcept { return mDelegate != nullptr; }
 
    private:
        void operator()(View* const view, Args... args) const {
            CE_ASSERT(view != nullptr);
            if(mDelegate) {
                mDelegate(*view, std::forward<Args>(args)...);
            }
        }
    };
 
    using UIColor = Color;
 
    struct UIUtility {
        static bool makeFirstResponder(UIView* view);
 
        static bool isOver(const UIView* view, const UIMouseEvent& event);
 
        static bool forwardInputEvent(UIWindow* window, const AnyInputEvent& event);
    };
 
    struct UILayoutUtility {
        static void layoutX(const UIView* views);
        static void layoutY(const UIView* views);
 
        static void sameWidth(std::initializer_list<UIView*> views);
        static void sameHeight(std::initializer_list<UIView*> views);
    };
 
    template<typename MemberPtr, typename T, typename... Args> void broadcast(MemberPtr&& member, const Vector<T>& list, Args&&... args) {
        for(auto& value : list) {
            if constexpr(std::is_pointer_v<T>) {
                (value->*member)(args...);
            } else {
                (value.*member)(args...);
            }
        }
    }
 
    template<typename MemberPtr, typename T, typename... Args> auto broadcastIf(MemberPtr&& member, const Vector<T>& list, Args&&... args) {
        for(auto& value : list) {
            auto invoke = [&]() {
                if constexpr(std::is_pointer_v<T>) {
                    return (value->*member)(args...);
                } else {
                    return (value.*member)(args...);
                }
            };
 
            if(auto ret = invoke()) {
                return ret;
            }
        }
 
        return false;
    }
 
    extern const UIRect UIRectZero;
 
} // namespace CeresEngine