XUIHOrVLayout.hpp

#pragma once
 
#include "../../UI/Components/CHLayout.hpp"
#include "../../UI/Components/CVLayout.hpp"
#include "IXUIElementWithChilds.hpp"
#include "IXUIBindable.hpp"
#include "IXUIElementReady.hpp"
 
namespace CP_SDK::XUI {
 
    template<class t_Base, class t_Component>
    class _XUIHOrVLayout
        : public IXUIElementWithChilds<t_Base>,
          public IXUIElementReady<t_Base, t_Component>,
          public IXUIBindable<t_Base>,
          public std::enable_shared_from_this<t_Base>
    {
        CP_SDK_NO_COPYMOVE_CTORS(_XUIHOrVLayout);
 
        private:
            _v::MonoPtr<t_Component> m_Element;
 
            _v::Event<t_Component*> m_OnReady;
 
        public:
            std::shared_ptr<t_Base> AsShared() { return std::enable_shared_from_this<t_Base>::shared_from_this(); }
 
            virtual _v::UIFieldRef<_u::RectTransform> RTransform() override
            {
                return m_Element ? m_Element->RTransform() : _v::UIFieldDefault<_u::RectTransform>::Value;
            }
            virtual _v::UIFieldRef<t_Component> Element()
            {
                return m_Element;
            }
 
        protected:
            _XUIHOrVLayout(std::u16string_view p_Name, IXUIElement::ETypeID p_TypeID, const std::vector<std::shared_ptr<IXUIElement>>& p_Childs)
                : IXUIElementWithChilds<t_Base>(p_Name, p_TypeID, p_Childs)
            { }
            _XUIHOrVLayout(std::u16string_view p_Name, IXUIElement::ETypeID p_TypeID, const std::vector<std::shared_ptr<IXUIElement>>& p_Childs) {…}
            virtual ~_XUIHOrVLayout() = default;
 
        public:
            virtual void BuildUI(_u::Transform* p_Parent) override
            {
                if constexpr (std::is_same_v<t_Component, _v::CHLayout>)
                    m_Element = _v::UISystem::HLayoutFactory->Create(IXUIElement::GetInitialName(), p_Parent);
                else
                    m_Element = _v::UISystem::VLayoutFactory->Create(IXUIElement::GetInitialName(), p_Parent);
 
                m_Element->SetSpacing(2.0f);
                m_Element->SetPadding(_u::RectOffset::New_ctor(2, 2, 2, 2));
 
                IXUIElementWithChilds<t_Base>::BuildUIChilds(m_Element->get_transform());
 
                try { m_OnReady(m_Element.Ptr()); m_OnReady.Clear(); }
                catch (const std::exception& l_Exception)
                {
                    if constexpr (std::is_same_v<t_Component, _v::CHLayout>)
                        ChatPlexSDK::Logger()->Error(u"[CP_SDK.XUI][_XUIHOrVLayout<CHLayout>.BuildUI] Error OnReady:");
                    else
                        ChatPlexSDK::Logger()->Error(u"[CP_SDK.XUI][_XUIHOrVLayout<CVLayout}>.BuildUI] Error OnReady:");
                    ChatPlexSDK::Logger()->Error(l_Exception);
                }
            }
            virtual void BuildUI(_u::Transform* p_Parent) override {…}
 
        public:
            virtual t_Base* OnReady(_v::CActionRef<t_Component*> p_Functor) override
            {
                if (m_Element)           p_Functor(m_Element.Ptr());
                else m_OnReady        += p_Functor;
                return reinterpret_cast<t_Base*>(this);
            }
            virtual t_Base* OnReady(_v::CActionRef<t_Component*> p_Functor) override {…}
            virtual t_Base* Bind(std::shared_ptr<t_Base>* p_Target) override
            {
                *p_Target = std::enable_shared_from_this<t_Base>::shared_from_this();
                return reinterpret_cast<t_Base*>(this);
            }
            virtual t_Base* Bind(std::shared_ptr<t_Base>* p_Target) override {…}
 
        public:
            t_Base* SetActive(bool p_Active) XUI_PROXY_IMPL_EX(t_Component, { x->get_gameObject()->SetActive(p_Active); })
 
        public:
            t_Base* SetBackground(bool p_Enabled, std::optional<_u::Color> p_Color = std::nullopt, bool p_RaycastTarget = false) XUI_PROXY_IMPL_EX(t_Component, { x->SetBackground(p_Enabled, p_Color, p_RaycastTarget); })
            t_Base* SetBackgroundColor(float p_Color) XUI_PROXY_IMPL_EX(t_Component, { x->SetBackgroundColor(p_Color); })
 
            t_Base* SetBackgroundFillMethod(_u::Image::FillMethod p_FillMethod) XUI_PROXY_IMPL_EX(t_Component, { x->SetBackgroundFillMethod(p_FillMethod); })
            t_Base* SetBackgroundFillAmount(float p_FillAmount) XUI_PROXY_IMPL_EX(t_Component, { x->SetBackgroundFillAmount(p_FillAmount); })
            t_Base* SetBackgroundSprite(_u::Sprite* p_Sprite, _u::Image::Type p_Type = _u::Image::Type::Simple) XUI_PROXY_IMPL_EX(t_Component, { x->SetBackgroundSprite(p_Sprite, p_Type); })
 
        public:
            t_Base* SetWidth(float p_Width) XUI_PROXY_IMPL_EX(t_Component, { x->SetWidth(p_Width); })
            t_Base* SetHeight(float p_Height) XUI_PROXY_IMPL_EX(t_Component, { x->SetHeight(p_Height); })
 
        public:
            t_Base* SetMinWidth(float p_Width) XUI_PROXY_IMPL_EX(t_Component, { x->SetMinWidth(p_Width); })
            t_Base* SetMinHeight(float p_Height) XUI_PROXY_IMPL_EX(t_Component, { x->SetMinHeight(p_Height); })
 
        public:
            t_Base* SetPadding(_u::RectOffset* p_Padding) XUI_PROXY_IMPL_EX(t_Component, { x->SetPadding(p_Padding); })
            t_Base* SetPadding(int p_Top, int p_Right, int p_Bottom, int p_Left) XUI_PROXY_IMPL_EX(t_Component, { x->SetPadding(p_Top, p_Right, p_Bottom, p_Left); })
            t_Base* SetPadding(int p_Padding) XUI_PROXY_IMPL_EX(t_Component, { x->SetPadding(p_Padding); })
 
        public:
            t_Base* SetSpacing(float p_Spacing) XUI_PROXY_IMPL_EX(t_Component, { x->SetSpacing(p_Spacing); })
 
    };
    class _XUIHOrVLayout {…};
 
}