WndBase.h

#pragma once
 
#include "App.h"
#include "Cursor.h"
#include "Delegate.h"
#include "Dip.h"
#include "Font.h"
#include "HitTestResult.h"
#include "IComparable.h"
#include "IToString.h"
#include "Keys.h"
#include "ObservableObject.h"
#include "Point.h"
#include "ProcMsg.h"
#include "Property.h"
#include "Rect.h"
#include "Size.h"
#include "WndMsg.h"
#include <Windows.h>
#include <string>
#include <type_traits>
#include <windowsx.h>
 
namespace sw
{
    class UIElement; // UIElement.h
    class Control;   // Control.h
    class Window;    // Window.h
 
    using SimpleAction = Action<>;
 
    class WndBase : public ObservableObject,
                    public IToString<WndBase>,
                    public IEqualityComparable<WndBase>
    {
        // 部分控件可能会改变HWND，设为友元类向Control类暴露_hwnd字段
        friend class Control;
 
        // HwndWrapper不使用InitWindow或InitControl初始化句柄，向其暴露底层细节以便实现相关功能
        friend class HwndWrapper;
 
    private:
        const uint32_t _check;
 
        HWND _hwnd = NULL;
 
        HFONT _hfont = NULL;
 
        sw::Font _font;
 
        sw::Rect _rect{};
 
        std::wstring _text{};
 
        bool _focused = false;
 
        bool _isDestroyed = false;
 
        bool _isControl = false;
 
        WNDPROC _originalWndProc = NULL;
 
    public:
        const ReadOnlyProperty<HWND> Handle;
 
        const Property<sw::Font> Font;
 
        const Property<std::wstring> FontName;
 
        const Property<double> FontSize;
 
        const Property<sw::FontWeight> FontWeight;
 
        const Property<sw::Rect> Rect;
 
        const Property<double> Left;
 
        const Property<double> Top;
 
        const Property<double> Width;
 
        const Property<double> Height;
 
        const ReadOnlyProperty<sw::Rect> ClientRect;
 
        const ReadOnlyProperty<double> ClientWidth;
 
        const ReadOnlyProperty<double> ClientHeight;
 
        const Property<bool> Enabled;
 
        const Property<bool> Visible;
 
        const Property<std::wstring> Text;
 
        const Property<bool> Focused;
 
        const ReadOnlyProperty<WndBase *> Parent;
 
        const ReadOnlyProperty<bool> IsDestroyed;
 
        const Property<bool> AcceptFiles;
 
        const ReadOnlyProperty<bool> IsControl;
 
        const ReadOnlyProperty<std::wstring> ClassName;
 
        const Property<bool> IsGroupStart;
 
        const ReadOnlyProperty<bool> IsMouseCaptured;
 
    protected:
        WndBase();
 
        WndBase(const WndBase &)            = delete; // 删除拷贝构造函数
        WndBase(WndBase &&)                 = delete; // 删除移动构造函数
        WndBase &operator=(const WndBase &) = delete; // 删除拷贝赋值运算符
        WndBase &operator=(WndBase &&)      = delete; // 删除移动赋值运算符
 
    public:
        virtual ~WndBase() = 0;
 
        virtual UIElement *ToUIElement();
 
        virtual Control *ToControl();
 
        virtual Window *ToWindow();
 
        bool Equals(const WndBase &other) const;
 
        virtual std::wstring ToString() const;
 
    protected:
        void InitWindow(LPCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle);
 
        void InitControl(LPCWSTR lpClassName, LPCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle, LPVOID lpParam = NULL);
 
        LRESULT DefaultWndProc(const ProcMsg &msg);
 
        virtual LRESULT WndProc(ProcMsg &refMsg);
 
        virtual std::wstring &GetInternalText();
 
        virtual void SetInternalText(const std::wstring &value);
 
        virtual bool OnCreate();
 
        virtual bool OnClose();
 
        virtual bool OnDestroy();
 
        virtual bool OnPaint();
 
        virtual void OnEndPaint();
 
        virtual bool OnNcPaint(HRGN hRgn);
 
        virtual void OnEndNcPaint();
 
        virtual bool OnMove(const Point &newClientPosition);
 
        virtual bool OnSize(const Size &newClientSize);
 
        virtual void OnTextChanged();
 
        virtual bool OnSetFocus(HWND hPrevFocus);
 
        virtual bool OnKillFocus(HWND hNextFocus);
 
        virtual bool OnMouseMove(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseLeave();
 
        virtual bool OnMouseWheel(int wheelDelta, const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseLeftButtonDown(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseLeftButtonUp(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseLeftButtonDoubleClick(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseRightButtonDown(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseRightButtonUp(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseRightButtonDoubleClick(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseMiddleButtonDown(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseMiddleButtonUp(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnMouseMiddleButtonDoubleClick(const Point &mousePosition, MouseKey keyState);
 
        virtual bool OnChar(wchar_t ch, const KeyFlags &flags);
 
        virtual bool OnDeadChar(wchar_t ch, const KeyFlags &flags);
 
        virtual bool OnKeyDown(VirtualKey key, const KeyFlags &flags);
 
        virtual bool OnKeyUp(VirtualKey key, const KeyFlags &flags);
 
        virtual bool OnSysChar(wchar_t ch, const KeyFlags &flags);
 
        virtual bool OnSysDeadChar(wchar_t ch, const KeyFlags &flags);
 
        virtual bool OnSysKeyDown(VirtualKey key, const KeyFlags &flags);
 
        virtual bool OnSysKeyUp(VirtualKey key, const KeyFlags &flags);
 
        virtual void VisibleChanged(bool newVisible);
 
        virtual bool SetParent(WndBase *parent);
 
        virtual void ParentChanged(WndBase *newParent);
 
        virtual void OnCommand(int code);
 
        virtual void OnControlCommand(WndBase *pControl, int code, int id);
 
        virtual void OnMenuCommand(int id);
 
        virtual void OnAcceleratorCommand(int id);
 
        virtual void HandleInitialized(HWND hwnd);
 
        virtual void FontChanged(HFONT hfont);
 
        virtual bool OnSetCursor(HWND hwnd, HitTestResult hitTest, int message, bool &result);
 
        virtual bool OnContextMenu(bool isKeyboardMsg, const Point &mousePosition);
 
        virtual bool OnMenuSelect(HMENU hMenu, int id, int flags);
 
        virtual bool OnNotify(NMHDR *pNMHDR, LRESULT &result);
 
        virtual bool OnNotified(NMHDR *pNMHDR, LRESULT &result);
 
        virtual bool OnVerticalScroll(int event, int pos);
 
        virtual bool OnHorizontalScroll(int event, int pos);
 
        virtual bool OnEnabledChanged(bool newValue);
 
        virtual bool OnCtlColor(WndBase *pControl, HDC hdc, HBRUSH &hRetBrush);
 
        virtual bool OnColor(HDC hdc, HBRUSH &hRetBrush);
 
        virtual void OnNcHitTest(const Point &testPoint, HitTestResult &result);
 
        virtual bool OnEraseBackground(HDC hdc, LRESULT &result);
 
        virtual bool OnDrawItem(int id, DRAWITEMSTRUCT *pDrawItem);
 
        virtual bool OnDrawItemSelf(DRAWITEMSTRUCT *pDrawItem);
 
        virtual bool OnMeasureItem(int id, MEASUREITEMSTRUCT *pMeasure);
 
        virtual bool OnMeasureItemSelf(MEASUREITEMSTRUCT *pMeasure);
 
        virtual bool OnDropFiles(HDROP hDrop);
 
    public:
        void UpdateInternalRect();
 
        void UpdateInternalText();
 
        void Show(int nCmdShow);
 
        void Close();
 
        void Update();
 
        void UpdateFont();
 
        HFONT GetFontHandle();
 
        void Redraw(bool erase = false, bool updateWindow = false);
 
        bool IsVisible() const;
 
        DWORD GetStyle() const;
 
        void SetStyle(DWORD style);
 
        bool GetStyle(DWORD mask) const;
 
        void SetStyle(DWORD mask, bool value);
 
        DWORD GetExtendedStyle() const;
 
        void SetExtendedStyle(DWORD style);
 
        bool GetExtendedStyle(DWORD mask);
 
        void SetExtendedStyle(DWORD mask, bool value);
 
        Point PointToScreen(const Point &point) const;
 
        Point PointFromScreen(const Point &screenPoint) const;
 
        LRESULT SendMessageA(UINT uMsg, WPARAM wParam, LPARAM lParam);
 
        LRESULT SendMessageW(UINT uMsg, WPARAM wParam, LPARAM lParam);
 
        BOOL PostMessageA(UINT uMsg, WPARAM wParam, LPARAM lParam);
 
        BOOL PostMessageW(UINT uMsg, WPARAM wParam, LPARAM lParam);
 
        HitTestResult NcHitTest(const Point &testPoint);
 
        void Invoke(const SimpleAction &action);
 
        void InvokeAsync(const SimpleAction &action);
 
        DWORD GetThreadId() const;
 
        bool CheckAccess() const;
 
        bool CheckAccess(const WndBase &other) const;
 
    public:
        static WndBase *GetWndBase(HWND hwnd) noexcept;
 
        static bool IsPtrValid(const WndBase *ptr) noexcept;
 
    private:
        static LRESULT CALLBACK _WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
        static WndBase *_GetControlInitContainer();
 
        static int _NextControlId();
 
        static void _SetWndBase(HWND hwnd, WndBase &wnd);
 
    public:
        template <typename TDerived, typename TProperty>
        auto GetProperty(TProperty TDerived::*prop)
            -> typename std::enable_if<
                std::is_base_of<WndBase, TDerived>::value && _IsReadableProperty<TProperty>::value,
                typename TProperty::TValue>::type
        {
            auto getter = Reflection::GetPropertyGetter(prop);
            return getter(*this);
        }
 
        template <typename TDerived, typename TProperty>
        auto SetProperty(TProperty TDerived::*prop, typename TProperty::TSetterParam value)
            -> typename std::enable_if<
                std::is_base_of<WndBase, TDerived>::value && _IsWritableProperty<TProperty>::value>::type
        {
            auto setter = Reflection::GetPropertySetter(prop);
            setter(*this, std::forward<typename TProperty::TSetterParam>(value));
        }
    };
}