Window.h

#pragma once
 
#include "IDialog.h"
#include "Layer.h"
 
namespace sw
{
    class Menu; // Menu.h
 
    enum class WindowState {
        Normal,    
        Minimized, 
        Maximized, 
    };
 
    enum class WindowStartupLocation {
        Manual,       
        CenterScreen, 
        CenterOwner,  
    };
 
    class Window : public Layer<UIElement>, 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 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();
    };
}