UIElement.h

#pragma once
 
#include "Alignment.h"
#include "Binding.h"
#include "Color.h"
#include "Cursor.h"
#include "EnumBit.h"
#include "EventHandlerWrapper.h"
#include "ILayout.h"
#include "RoutedEvent.h"
#include "RoutedEventArgs.h"
#include "Thickness.h"
#include "WndBase.h"
#include <cstdint>
#include <unordered_map>
#include <vector>
 
namespace sw
{
    // 前向声明
    class UIElement;
    class ContextMenu;
    class DataBinding;
 
    enum class LayoutUpdateCondition : uint32_t {
        SizeChanged = 1 << 0,
 
        PositionChanged = 1 << 1,
 
        ChildAdded = 1 << 2,
 
        ChildRemoved = 1 << 3,
 
        TextChanged = 1 << 4,
 
        FontChanged = 1 << 5,
 
        MeasureInvalidated = 1 << 29,
 
        Supressed = 1 << 30,
    };
 
    _SW_ENUM_ENABLE_BIT_OPERATIONS(LayoutUpdateCondition);
 
    class UIElement : public WndBase,
                      public ILayout
    {
    private:
        sw::LayoutUpdateCondition _layoutUpdateCondition =
            sw::LayoutUpdateCondition::SizeChanged |
            sw::LayoutUpdateCondition::ChildAdded |
            sw::LayoutUpdateCondition::ChildRemoved;
 
        bool _collapseWhenHide = true;
 
        Size _desireSize{};
 
        Size _origionalSize{};
 
        Size _minSize{-1, -1};
 
        Size _maxSize{-1, -1};
 
        Thickness _margin{};
 
        HorizontalAlignment _horizontalAlignment = HorizontalAlignment::Center;
 
        VerticalAlignment _verticalAlignment = VerticalAlignment::Center;
 
        UIElement *_parent = nullptr;
 
        std::vector<UIElement *> _children{};
 
        std::vector<UIElement *> _layoutVisibleChildren{};
 
        std::unordered_map<RoutedEventType, RoutedEventHandler> _eventMap{};
 
        uint64_t _layoutTag = 0;
 
        sw::ContextMenu *_contextMenu = nullptr;
 
        double _arrangeOffsetX = 0;
 
        double _arrangeOffsetY = 0;
 
        double _childRightmost = 0;
 
        double _childBottommost = 0;
 
        bool _float = false;
 
        bool _tabStop = false;
 
        Color _backColor{KnownColors::White};
 
        Color _textColor{KnownColors::Black};
 
        bool _transparent = false;
 
        bool _inheritTextColor = false;
 
        bool _useDefaultCursor = true;
 
        HCURSOR _hCursor = NULL;
 
        Size _lastMeasureAvailableSize{};
 
        HDWP _hdwpChildren = NULL;
 
        HBRUSH _hCtlColorBrush = NULL;
 
        COLORREF _lastTextColor = 0;
 
        COLORREF _lastBackColor = 0;
 
        bool _isHitTestVisible = true;
 
        bool _focusedViaTab = false;
 
        std::unordered_map<FieldId, std::unique_ptr<BindingBase>> _bindings{};
 
    public:
        const Property<Thickness> Margin;
 
        const Property<HorizontalAlignment> HorizontalAlignment;
 
        const Property<VerticalAlignment> VerticalAlignment;
 
        const ReadOnlyProperty<int> ChildCount;
 
        const Property<bool> CollapseWhenHide;
 
        const Property<uint64_t> LayoutTag;
 
        const Property<sw::ContextMenu *> ContextMenu;
 
        const Property<bool> Float;
 
        const Property<bool> TabStop;
 
        const Property<Color> BackColor;
 
        const Property<Color> TextColor;
 
        const Property<bool> Transparent;
 
        const Property<bool> InheritTextColor;
 
        const Property<sw::LayoutUpdateCondition> LayoutUpdateCondition;
 
        const ReadOnlyProperty<bool> IsMeasureValid;
 
        const Property<double> MinWidth;
 
        const Property<double> MinHeight;
 
        const Property<double> MaxWidth;
 
        const Property<double> MaxHeight;
 
        const ReadOnlyProperty<sw::Rect> LogicalRect;
 
        const Property<bool> IsHitTestVisible;
 
        const ReadOnlyProperty<bool> IsFocusedViaTab;
 
    public:
        UIElement();
 
        virtual ~UIElement() = 0;
 
        [[deprecated("Use AddHandler instead to avoid overwriting existing event handlers.")]]
        void RegisterRoutedEvent(RoutedEventType eventType, const RoutedEventHandler &handler);
 
        void AddHandler(RoutedEventType eventType, const RoutedEventHandler &handler);
 
        bool RemoveHandler(RoutedEventType eventType, const RoutedEventHandler &handler);
 
        void UnregisterRoutedEvent(RoutedEventType eventType);
 
        bool IsRoutedEventRegistered(RoutedEventType eventType);
 
        bool AddChild(UIElement *element);
 
        bool AddChild(UIElement &element);
 
        bool AddChild(UIElement *element, uint64_t layoutTag);
 
        bool AddChild(UIElement &element, uint64_t layoutTag);
 
        bool RemoveChildAt(int index);
 
        bool RemoveChild(UIElement *element);
 
        bool RemoveChild(UIElement &element);
 
        void ClearChildren();
 
        int IndexOf(UIElement *element);
 
        int IndexOf(UIElement &element);
 
        bool ShowContextMenu(
            const Point &point,
            sw::HorizontalAlignment horz = sw::HorizontalAlignment::Left,
            sw::VerticalAlignment vert   = sw::VerticalAlignment::Top);
 
        void MoveToTop();
 
        void MoveToBottom();
 
        bool IsRootElement() const;
 
        UIElement *GetRootElement();
 
        UIElement *GetNextElement();
 
        UIElement *GetPreviousElement();
 
        UIElement *GetNextTabStopElement();
 
        UIElement *GetPreviousTabStopElement();
 
        Color GetRealBackColor() const;
 
        Color GetRealTextColor() const;
 
        void SetCursor(HCURSOR hCursor);
 
        void SetCursor(StandardCursor cursor);
 
        void ResetCursor();
 
        void SetAlignment(sw::HorizontalAlignment horz, sw::VerticalAlignment vert);
 
        void Resize(const Size &size);
 
        bool IsLayoutUpdateConditionSet(sw::LayoutUpdateCondition condition);
 
        void InvalidateMeasure();
 
        bool BringIntoView();
 
        virtual UIElement *ToUIElement() override final;
 
        virtual UIElement *GetParent() const override final;
 
        virtual int GetChildCount() const override final;
 
        virtual UIElement &GetChildAt(int index) const override final;
 
        virtual uint64_t GetLayoutTag() const override;
 
        virtual int GetChildLayoutCount() const override final;
 
        virtual ILayout &GetChildLayoutAt(int index) const override final;
 
        virtual Size GetDesireSize() const override;
 
        virtual void Measure(const Size &availableSize) override;
 
        virtual void Arrange(const sw::Rect &finalPosition) override;
 
    protected:
        void RaiseRoutedEvent(RoutedEventType eventType);
 
        void RaiseRoutedEvent(RoutedEventArgs &eventArgs);
 
        double &GetInternalArrangeOffsetX();
 
        double &GetInternalArrangeOffsetY();
 
        double GetChildRightmost(bool update);
 
        double GetChildBottommost(bool update);
 
        void UpdateChildrenZOrder(bool invalidateMeasure = true);
 
        void UpdateSiblingsZOrder(bool invalidateMeasure = true);
 
        void ClampDesireSize(sw::Size &size) const;
 
        void ClampDesireSize(sw::Rect &rect) const;
 
        bool QueryAllChildren(const Predicate<UIElement *> &queryFunc);
 
        bool QueryAllElements(const Predicate<UIElement *> &queryFunc);
 
        virtual Size MeasureOverride(const Size &availableSize);
 
        virtual void ArrangeOverride(const Size &finalSize);
 
        virtual void SetBackColor(Color color, bool redraw);
 
        virtual void SetTextColor(Color color, bool redraw);
 
        virtual bool RequestBringIntoView(const sw::Rect &screenRect);
 
        virtual void OnAddedChild(UIElement &element);
 
        virtual void OnRemovedChild(UIElement &element);
 
        virtual void OnTabMove(bool forward);
 
        virtual void OnTabStop();
 
        virtual void OnMinMaxSizeChanged();
 
        virtual void OnRoutedEvent(RoutedEventArgs &eventArgs, const RoutedEventHandler &handler);
 
        virtual bool SetParent(WndBase *parent) override;
 
        virtual void ParentChanged(WndBase *newParent) override;
 
        virtual bool OnClose() override;
 
        virtual bool OnMove(const Point &newClientPosition) override;
 
        virtual bool OnSize(const Size &newClientSize) override;
 
        virtual void OnTextChanged() override;
 
        virtual void FontChanged(HFONT hfont) override;
 
        virtual void VisibleChanged(bool newVisible) override;
 
        virtual bool OnSetFocus(HWND hPrevFocus) override;
 
        virtual bool OnKillFocus(HWND hNextFocus) override;
 
        virtual bool OnChar(wchar_t ch, const KeyFlags &flags) override;
 
        virtual bool OnKeyDown(VirtualKey key, const KeyFlags &flags) override;
 
        virtual bool OnKeyUp(VirtualKey key, const KeyFlags &flags) override;
 
        virtual bool OnMouseMove(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseLeave() override;
 
        virtual bool OnMouseWheel(int wheelDelta, const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseLeftButtonDown(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseLeftButtonUp(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseRightButtonDown(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseRightButtonUp(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseMiddleButtonDown(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnMouseMiddleButtonUp(const Point &mousePosition, MouseKey keyState) override;
 
        virtual bool OnContextMenu(bool isKeyboardMsg, const Point &mousePosition) override;
 
        virtual void OnMenuCommand(int id) override;
 
        virtual bool OnColor(HDC hdc, HBRUSH &hRetBrush) override;
 
        virtual bool OnSetCursor(HWND hwnd, HitTestResult hitTest, int message, bool &result) override;
 
        virtual bool OnDropFiles(HDROP hDrop) override;
 
        virtual void OnNcHitTest(const Point &testPoint, HitTestResult &result) override;
 
    private:
        bool _SetHorzAlignment(sw::HorizontalAlignment value);
 
        bool _SetVertAlignment(sw::VerticalAlignment value);
 
        void _SetMeasureInvalidated();
 
        void _UpdateLayoutVisibleChildren();
 
        bool _AddToLayoutVisibleChildren(UIElement *element);
 
        void _RemoveFromLayoutVisibleChildren(UIElement *element);
 
        static UIElement *_GetNextElement(UIElement *element);
 
        static UIElement *_GetDeepestLastElement(UIElement *element);
 
        static UIElement *_GetPreviousElement(UIElement *element);
 
    private:
        template <typename T, typename = void>
        struct _CanAddChild : std::false_type {
        };
 
        // 已移动到类外，防止clang报错不完整的类型
        // /**
        //  * @brief _CanAddChild模板偏特化，当AddChild有对应类型的重载时该偏特化生效
        //  */
        // template <typename T>
        // struct _CanAddChild<
        //     T, decltype(void(std::declval<UIElement>().AddChild(std::declval<T>())))> : std::true_type {
        // };
 
        template <typename First, typename... Rest>
        struct _CanAddChildren
            : std::integral_constant<bool, _CanAddChild<First>::value && _CanAddChildren<Rest...>::value> {
        };
 
        template <typename T>
        struct _CanAddChildren<T> : _CanAddChild<T> {
        };
 
        template <typename T>
        int _AddChildrenImpl(T &&child)
        {
            return this->AddChild(std::forward<T>(child)) ? 1 : 0;
        }
 
        template <typename First, typename... Rest>
        int _AddChildrenImpl(First &&first, Rest &&...rest)
        {
            int count = 0;
            if (this->AddChild(std::forward<First>(first)))
                count = 1 + this->_AddChildrenImpl(std::forward<Rest>(rest)...);
            return count;
        }
 
    public:
        template <typename First, typename... Rest>
        auto AddChildren(First &&first, Rest &&...rest)
            -> typename std::enable_if<_CanAddChildren<First, Rest...>::value, int>::type
        {
            this->_layoutUpdateCondition |= sw::LayoutUpdateCondition::Supressed;
            int count = this->_AddChildrenImpl(std::forward<First>(first), std::forward<Rest>(rest)...);
            this->_layoutUpdateCondition &= ~sw::LayoutUpdateCondition::Supressed;
 
            if (this->IsLayoutUpdateConditionSet(sw::LayoutUpdateCondition::ChildAdded) && count > 0)
                this->InvalidateMeasure();
            return count;
        }
 
        template <typename T>
        [[deprecated("Use AddHandler instead to avoid overwriting existing event handlers.")]]
        void RegisterRoutedEvent(RoutedEventType eventType, T &obj, void (T::*handler)(UIElement &, RoutedEventArgs &))
        {
            if (handler == nullptr) {
                this->UnregisterRoutedEvent(eventType);
            } else {
                this->RegisterRoutedEvent(eventType, RoutedEventHandler(obj, handler));
            }
        }
 
        template <typename TEventArgs>
        [[deprecated("Use AddHandler instead to avoid overwriting existing event handlers.")]]
        auto RegisterRoutedEvent(const Action<UIElement &, TEventArgs &> &handler)
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (!handler) {
                this->UnregisterRoutedEvent(TEventArgs::EventType);
            } else {
                this->RegisterRoutedEvent(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(handler));
            }
        }
 
        template <typename TEventArgs, typename THandleObj>
        [[deprecated("Use AddHandler instead to avoid overwriting existing event handlers.")]]
        auto RegisterRoutedEvent(THandleObj &obj, void (THandleObj::*handler)(UIElement &, TEventArgs &))
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (handler == nullptr) {
                this->UnregisterRoutedEvent(TEventArgs::EventType);
            } else {
                this->RegisterRoutedEvent(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(Action<UIElement &, TEventArgs &>(obj, handler)));
            }
        }
 
        template <typename T>
        void AddHandler(RoutedEventType eventType, T &obj, void (T::*handler)(UIElement &, RoutedEventArgs &))
        {
            if (handler) this->_eventMap[eventType].Add(obj, handler);
        }
 
        template <typename TEventArgs>
        auto AddHandler(const Action<UIElement &, TEventArgs &> &handler)
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (handler) this->AddHandler(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(handler));
        }
 
        template <typename TEventArgs, typename THandleObj>
        auto AddHandler(THandleObj &obj, void (THandleObj::*handler)(UIElement &, TEventArgs &))
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (handler) this->AddHandler(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(Action<UIElement &, TEventArgs &>(obj, handler)));
        }
 
        template <typename TEventArgs>
        auto AddHandler(RoutedEventType eventType, const Action<UIElement &, TEventArgs &> &handler)
            -> typename std::enable_if<
                std::is_base_of<RoutedEventArgs, TEventArgs>::value &&
                !std::is_same<TEventArgs, RoutedEventArgs>::value &&
                !sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (handler) this->AddHandler(eventType, RoutedEventHandlerWrapper<TEventArgs>(handler));
        }
 
        template <typename TEventArgs, typename THandleObj>
        auto AddHandler(RoutedEventType eventType, THandleObj &obj, void (THandleObj::*handler)(UIElement &, TEventArgs &))
            -> typename std::enable_if<
                std::is_base_of<RoutedEventArgs, TEventArgs>::value &&
                !std::is_same<TEventArgs, RoutedEventArgs>::value &&
                !sw::_IsTypedRoutedEventArgs<TEventArgs>::value>::type
        {
            if (handler) this->AddHandler(eventType, RoutedEventHandlerWrapper<TEventArgs>(Action<UIElement &, TEventArgs &>(obj, handler)));
        }
 
        template <typename T>
        bool RemoveHandler(RoutedEventType eventType, T &obj, void (T::*handler)(UIElement &, RoutedEventArgs &))
        {
            return handler == nullptr ? false : this->_eventMap[eventType].Remove(obj, handler);
        }
 
        template <typename TEventArgs>
        auto RemoveHandler(const Action<UIElement &, TEventArgs &> &handler)
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value, bool>::type
        {
            if (handler == nullptr) {
                return false;
            } else {
                return this->RemoveHandler(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(handler));
            }
        }
 
        template <typename TEventArgs, typename THandleObj>
        auto RemoveHandler(THandleObj &obj, void (THandleObj::*handler)(UIElement &, TEventArgs &))
            -> typename std::enable_if<std::is_base_of<RoutedEventArgs, TEventArgs>::value && sw::_IsTypedRoutedEventArgs<TEventArgs>::value, bool>::type
        {
            if (handler == nullptr) {
                return false;
            } else {
                return this->RemoveHandler(TEventArgs::EventType, RoutedEventHandlerWrapper<TEventArgs>(Action<UIElement &, TEventArgs &>(obj, handler)));
            }
        }
 
        template <typename TEventArgs>
        auto RemoveHandler(RoutedEventType eventType, const Action<UIElement &, TEventArgs &> &handler)
            -> typename std::enable_if<
                std::is_base_of<RoutedEventArgs, TEventArgs>::value &&
                    !std::is_same<TEventArgs, RoutedEventArgs>::value &&
                    !sw::_IsTypedRoutedEventArgs<TEventArgs>::value,
                bool>::type
        {
            if (handler == nullptr) {
                return false;
            } else {
                return this->RemoveHandler(eventType, RoutedEventHandlerWrapper<TEventArgs>(handler));
            }
        }
 
        template <typename TEventArgs, typename THandleObj>
        auto RemoveHandler(RoutedEventType eventType, THandleObj &obj, void (THandleObj::*handler)(UIElement &, TEventArgs &))
            -> typename std::enable_if<
                std::is_base_of<RoutedEventArgs, TEventArgs>::value &&
                    !std::is_same<TEventArgs, RoutedEventArgs>::value &&
                    !sw::_IsTypedRoutedEventArgs<TEventArgs>::value,
                bool>::type
        {
            if (handler == nullptr) {
                return false;
            } else {
                return this->RemoveHandler(eventType, RoutedEventHandlerWrapper<TEventArgs>(Action<UIElement &, TEventArgs &>(obj, handler)));
            }
        }
    };
 
    template <typename T>
    struct UIElement::_CanAddChild<
        T, decltype(void(std::declval<UIElement>().AddChild(std::declval<T>())))> : std::true_type {
    };
}