Window.h

#pragma once
 
#include "Color.h"
#include "Cursor.h"
#include "IDialog.h"
#include "Layer.h"
#include "Menu.h"
#include "Screen.h"
#include "UIElement.h"
 
namespace sw
{
    enum class WindowState {
        Normal,    // 普通窗口
        Minimized, // 最小化窗口
        Maximized, // 最大化窗口
    };
 
    enum class WindowStartupLocation {
        Manual,       // 使用系统默认或手动设置
        CenterScreen, // 屏幕中心
        CenterOwner,  // 所有者窗口中心
    };
 
    class Window : public Layer, public IDialog
    {
    private:
        using TBase = Layer;
 
        bool _isFirstShow = true;
 
        WindowStartupLocation _startupLocation = WindowStartupLocation::Manual;
 
        sw::Menu *_menu = nullptr;
 
        HWND _hPrevFocused = NULL;
 
        std::unique_ptr<LayoutHost> _defaultLayout;
 
        bool _isModal = false;
 
        HWND _hModalOwner = NULL;
 
        bool _isBorderless = false;
 
        int _dialogResult = 0;
 
        bool _isDestroying = false;
 
        int _disableLayoutCount = 0;
 
    public:
        static const ReadOnlyProperty<Window *> ActiveWindow;
 
        static const ReadOnlyProperty<int> WindowCount;
 
        const Property<WindowStartupLocation> StartupLocation;
 
        const Property<WindowState> State;
 
        const Property<bool> SizeBox;
 
        const Property<bool> MaximizeBox;
 
        const Property<bool> MinimizeBox;
 
        const Property<bool> Topmost;
 
        const Property<bool> ToolWindow;
 
        const Property<sw::Menu *> Menu;
 
        const ReadOnlyProperty<bool> IsModal;
 
        const Property<Window *> Owner;
 
        const Property<bool> IsLayered;
 
        const Property<double> Opacity;
 
        const Property<bool> Borderless;
 
        const Property<int> DialogResult;
 
        const ReadOnlyProperty<sw::Rect> RestoreRect;
 
        const ReadOnlyProperty<bool> IsLayoutDisabled;
 
    public:
        Window();
 
        ~Window();
 
    protected:
        virtual LRESULT WndProc(ProcMsg &refMsg) override;
 
        virtual LayoutHost *GetDefaultLayout() override;
 
        virtual bool OnCreate() override;
 
        virtual bool OnClose() override;
 
        virtual bool OnDestroy() override;
 
        virtual bool OnEraseBackground(HDC hdc, LRESULT &result) override;
 
        virtual bool OnPaint() override;
 
        virtual void OnMenuCommand(int id) override;
 
        virtual void OnMinMaxSizeChanged() override;
 
        virtual void OnFirstShow();
 
        virtual void OnActived();
 
        virtual void OnInactived();
 
        virtual bool OnDpiChanged(int dpiX, int dpiY, RECT &newRect);
 
    public:
        virtual Window *ToWindow() override;
 
        virtual void Close() override;
 
        virtual void Show() override;
 
        virtual int ShowDialog(Window *owner = nullptr) override;
 
        virtual int ShowDialog(Window &owner);
 
        bool DisableLayout();
 
        bool EnableLayout(bool reset = false);
 
        void SetIcon(HICON hIcon);
 
        void DrawMenuBar();
 
        bool SizeToContent();
 
        template <typename TLayout>
        auto SetLayout()
            -> typename std::enable_if<std::is_base_of<LayoutHost, TLayout>::value>::type
        {
            auto layout = std::make_unique<TLayout>();
            layout->Associate(this);
            _defaultLayout = std::move(layout);
            InvalidateMeasure();
        }
 
        template <std::nullptr_t>
        void SetLayout()
        {
            _defaultLayout.reset(nullptr);
            InvalidateMeasure();
        }
 
    private:
        bool _IsLayoutDisabled() const noexcept;
 
        void _CenterWindow(const sw::Rect &rect);
 
        void _ClampMinMaxSize(PMINMAXINFO pInfo);
 
        static Window *_GetWindowPtr(HWND hwnd);
 
        static void _SetWindowPtr(HWND hwnd, Window &wnd);
 
        static HICON _GetWindowDefaultIcon();
    };
}