gui_os_window_manager.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/gui_id.h>
 
#include <gui_core/windows/gui_window_backend.h>
#include <gui_core/windows/gui_window_flags.h>
 
#include <functional>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
 
namespace tachyon
{
 
    // Forward declarations
    class GraphicsContext;
    class IWindowBackend;
    class ImageSet;
    class StyleManager;
    class GraphicsContext;
    class GradientManager;

    enum class AddWindowResult : int8_t
    {
        SuccessCreate          =  0, 
        SuccessRecycle         =  1, 
        CalledOutsideOfFrame   = -1, 
        IndexOutOfBounds       = -2, 
        FailedToCreateOSWindow = -3, 
        InvalidID              = -4, 
        WindowUserClosed       = -5  
    };

    enum class RequestCloseResult : int8_t
    {
        Success             =  0, 
        CalledOutsideFrame  = -1, 
        IndexOutOfBounds    = -2, 
        WindowAlreadyClosed = -3, 
        UnknownError        = -4  
    };

    enum class WindowState : uint8_t
    {
        NotRegistered,  
        Alive,          
        Closing,        
        Hidden          
    };

    class OSWindowManager 
    {
    private:
        // ---------------- Window Data ----------------
 
        struct Window 
        {
            ID              id = ID::Invalid();
 
            WindowState     state         = WindowState::Alive;
            WindowFlags     flags         = WindowFlags::None;
 
            ID              parentID      = ID::Invalid();
            ID              firstChildID  = ID::Invalid();
            ID              nextSiblingID = ID::Invalid();
            int32_t         childCount    = 0;
 
            IntRect         rect{};             
            IntRect         lastRect{};         
 
            int32_t         monitorIndex  = -1;
            float           displayScale  = 1.0f; 
            uint32_t        sequence      = 0;    
            int32_t         framesHidden  = 0;    
            bool            cloaked       = false; 
 
            // A popup fading in or out is shown by a layered stand-in (IWindowBackend::ShowFade)
            // while the window itself is cloaked (in) or hidden (out).
            uint32_t        fade          = 0;     
            int32_t         fadeWait      = -1;    
            bool            fadingIn      = false; 
            float           fadeFrom      = 0.0f;  
            uint32_t        fadeStartMs   = 0;
            int2            slide         { 0, 1 }; 
 
            OSWindowHandle  osHandle = nullptr;
            IWindowContext* context  = nullptr;
            OnGuiFunc       onGui;              
 
            OSWindowHandle  GetWindowHandle() const { return osHandle; }
        };
 
        std::vector<MonitorInfo> monitors;
        uint32_t m_nextSequence = 0;
        ID      m_textInputWindow = ID::Invalid();
        uint32_t m_focusChangeCount = 0;   
        IntRect m_textInputArea {};
        int primaryMonitorIndex = 0;
 
        bool insideBeginEnd = false;
 
    protected:
        OSWindowManager() = default;

        StyleManager*    styleManager    = nullptr;
        GradientManager* gradientManager = nullptr;
 
        IPlatformInputHandler* inputHandler = nullptr;
 
    public:
        virtual ~OSWindowManager() = default;
        explicit OSWindowManager(GraphicsContext* graphicsContext, IWindowBackend* backend);
        OSWindowManager(GraphicsContext* graphicsContext, IWindowBackend* backendWindowManager,
                        IPlatformInputHandler* inputHandler, StyleManager& styleManager, GradientManager& gradientManager);
 
 
        // ---------------- Popup motion ----------------
 
        static constexpr uint32_t kPopupInMs   = 120; 
        static constexpr uint32_t kTooltipInMs = 100; 
        static constexpr uint32_t kPopupOutMs  = 80;  
        static constexpr int      kPopupSlide  = 4;   

        void SetPopupSlide(ID id, int2 away);
        void SetReducedMotion(bool reduced) { m_reducedMotion = reduced; }
 
        // ---------------- Frame Lifecycle ---------------- 

        bool BeginFrame();
 
        bool EndFrame();
 
        // ---------------- Declared windows ----------------

        void ReleaseUndeclaredWindows(const std::function<bool(ID)>& declared);
 
        // ---------------- Input ----------------

        bool HasAlivePopupWindows() const
        {
            for (const auto& w : windows)
                if (w.state == WindowState::Alive &&
                    (w.flags & WindowFlags::PopupMenu) != WindowFlags::None)
                    return true;
            return false;
        }

        bool HasAliveSecondaryWindows() const
        {
            const WindowFlags kSecondary = WindowFlags::PopupMenu
                                         | WindowFlags::Utility;
            for (const auto& w : windows)
                if (w.state == WindowState::Alive &&
                    (w.flags & kSecondary) != WindowFlags::None)
                    return true;
            return false;
        }

        void HidePopupWindow(ID id)
        {
            auto* w = FindWindow(id);
            if (w == nullptr || w->state != WindowState::Alive) return;
            w->state = WindowState::Hidden;
            windowBackendManager->SetWindowVisible(w->GetWindowHandle(), false);
        }

        void SetTextInputArea(ID id, IntRect screenRect)
        {
            auto* w = FindWindow(id);
            if (w == nullptr || w->state != WindowState::Alive) return;
            const IntRect local{ screenRect.x - w->rect.x, screenRect.y - w->rect.y, screenRect.w, screenRect.h };
            if (id == m_textInputWindow && local == m_textInputArea) return;
            m_textInputWindow = id;
            m_textInputArea   = local;
            windowBackendManager->SetTextInputArea(w->GetWindowHandle(), local);
        }

        bool Update();

        void DestroyAllWindowContexts();
 
        std::optional<color4b> ReadScreenPixel(int2 screenPos)
        {
            return windowBackendManager->ReadScreenPixel(screenPos);
        }

        bool TakeCloseRequest(ID id)
        {
            const int32_t index = IndexOf(id);
            return index >= 0 && windowBackendManager->TakeCloseRequest(windows[size_t(index)].GetWindowHandle());
        }
 
        int2 GetScreenMousePos()
        {
            return windowBackendManager->GetScreenMousePos();
        }
 
        MouseButtons GetMouseButtons()
        {
            return windowBackendManager->GetMouseButtons();
        }
 
        // ---------------- Window Creation ---------------- 
 
        inline bool IsNotAlive(ID id) const { return IsNotAlive(IndexOf(id)); }

        AddWindowResult
            GetOrCreateWindow(ID id, std::string_view title, IntRect rect,
                              OnGuiFunc onGui,
                              WindowFlags windowFlags = WindowFlags::DefaultFlags | WindowFlags::CloseWithParent,
                              ID parentID = ID::Invalid(), int monitorIndex = -1);
 
        // ---------------- Monitor State ---------------- 
 
        void RefreshMonitors()
        {
            monitors = windowBackendManager->GetMonitors();
            for (size_t i = 0; i < monitors.size(); ++i)
            {
                if (monitors[i].isPrimary)
                {
                    primaryMonitorIndex = static_cast<int>(i);
                    break;
                }
            }
        }
 
        size_t GetMonitorCount() const
        {
            return monitors.size();
        }
 
        IntRect GetMonitorArea(int monitorIndex);
        IntRect CenterInMonitor(int monitorIndex, int width, int height);
 
        const std::vector<MonitorInfo>& Monitors() const { return monitors; }
 
        const MonitorInfo &GetMonitor(int index) const
        {
            return (index >= 0 && index < static_cast<int>(monitors.size()))
                       ? monitors[index]
                       : GetPrimaryMonitor();
        }
 
        int GetMonitorIndexAt(int2 pos) const
        {
            return windowBackendManager->GetMonitorAt(pos);
        }
 
        int GetPrimaryMonitorIndex() const
        {
            if (primaryMonitorIndex < 0 || size_t(primaryMonitorIndex) >= monitors.size())
                return -1;
            return primaryMonitorIndex;
        }
 
        const MonitorInfo &GetPrimaryMonitor() const
        {
            static MonitorInfo kEmptyInfo{.isPrimary = true};
            if (primaryMonitorIndex < 0 || size_t(primaryMonitorIndex) >= monitors.size())
                return kEmptyInfo; // no monitor connected
            return monitors[primaryMonitorIndex];
        }        

        bool SetWindowRect(ID id, const IntRect &clientRect);
                
        // ---------------- Window State ---------------- 
 
        RequestCloseResult RequestClose(ID id) { return RequestClose(IndexOf(id)); }

        RequestCloseResult RequestUserClose(ID id)
        {
            userClosedWindows.insert(id);
            return RequestClose(IndexOf(id));
        }
        
        RequestCloseResult RequestCloseAllowReopen(ID id)
        {
            // Remove from user-closed set if present (allow reopening)
            userClosedWindows.erase(id);
            return RequestClose(IndexOf(id));
        }
        
        void AllowReopenWindow(ID id)
        {
            userClosedWindows.erase(id);
        }
        
        bool WasUserClosed(ID id) const
        {
            return userClosedWindows.find(id) != userClosedWindows.end();
        }
 
        WindowState GetWindowState(ID id) const
        {
            int32_t index = IndexOf(id);
            return index == -1 ? WindowState::NotRegistered : windows[index].state;
        }
 
        bool HasBeenRegistered(ID id) const
        {
            int32_t index = IndexOf(id);
            return index != -1;
        }

        float GetWindowDisplayScale(ID id) const
        {
            int32_t index = IndexOf(id);
            return index == -1 ? 1.0f : windows[index].displayScale;
        }

        float MainDisplayScale() const;

        float MainRefreshRate() const;

        IWindowContext* GetWindowContext(ID id) const
        {
            const int32_t index = IndexOf(id);
            return index == -1 ? nullptr : windows[index].context;
        }
        OSWindowHandle GetWindowHandle(ID id) const
        {
            const int32_t index = IndexOf(id);
            return index == -1 ? nullptr : windows[index].GetWindowHandle();
        }

        ID GetWindowID(OSWindowHandle handle) const
        {
            const int32_t index = IndexOf(handle);
            return index == -1 ? ID::Invalid() : windows[index].id;
        }
 
        void SetWindowMode(ID id, WindowMode mode) { if (OSWindowHandle h = GetWindowHandle(id)) windowBackendManager->SetWindowMode(h, mode); }
        WindowMode GetWindowMode(ID id) const
        {
            const OSWindowHandle h = GetWindowHandle(id);
            return h != nullptr ? windowBackendManager->GetWindowMode(h) : WindowMode::Normal;
        }
 
        IntRect GetWindowRect(ID id) const
        {
            int32_t index = IndexOf(id);
            return index == -1 ? IntRect{} : windows[index].rect;
        }
 
        int2 GetWindowSize(ID id) const
        {
            int32_t index = IndexOf(id);
            return index == -1 ? int2 {} : windows[index].rect.size;
        }
 
        int2 GetWindowPosition(ID id) const
        {
            int32_t index = IndexOf(id);
            return index == -1 ? int2 {} : windows[index].rect.position;
        }
 
        // ---------------- Focus & Z Order ---------------- 
 
        void BringToFront(ID id) 
        {
            int32_t index = IndexOf(id);
            if (index == -1) return;
            windowBackendManager->BringToFront(windows[index].GetWindowHandle());
        }
 
        ID GetWindowUnderMouse() const
        {
            OSWindowHandle handle = windowBackendManager->GetWindowUnderMouse();
            if (handle == nullptr) return ID::Invalid(); // No active window
            int32_t index = IndexOf(handle);
            if (index == -1) return ID::Invalid();
            return windows[index].id;
        }
 
        ID GetActiveWindow() const
        {
            OSWindowHandle handle = windowBackendManager->GetActiveWindow();
            if (handle == nullptr)
            {
                return ID::Invalid(); // No active window
            }
            int32_t index = IndexOf(handle);
            if (index == -1)
            {
                // No active window, or active window not managed by us
                return ID::Invalid();
            }
            return windows[index].id;
        }
        
        // ---------------- Queries ---------------- 
        
        size_t WindowCount() const { return windows.size(); }
        const std::vector<Window> &AllWindows() const { return windows; }

        bool HasAliveMainWindow() const
        {
            const WindowFlags auxFlags = WindowFlags::PopupMenu | WindowFlags::NotFocusable;
            for (const auto& w : windows)
                if (w.state == WindowState::Alive &&
                    (w.flags & auxFlags) == WindowFlags::None)
                    return true;
            return false;
        }
        
        ID GetTopModalWindow() const;
 
        bool WasWindowUserClosed(ID id) const
        {
            return userClosedWindows.find(id) != userClosedWindows.end();
        }

        void DestroyWindowContexts();
        bool RecreateWindowContexts();

        void ForEachAliveWindowContext(const std::function<void(IWindowContext*, IntRect)>& func)
        {
            for (const auto& w : windows)
            {
                if (w.state == WindowState::Alive && w.context != nullptr)
                {
                    func(w.context, windowBackendManager->GetWindowPixelRect(w.GetWindowHandle()));
                }
            }
        }
 
    protected:
        GraphicsContext* graphicsContext = nullptr;
        IWindowBackend*  windowBackendManager = nullptr;
 
        std::vector<Window> windows;
        std::unordered_map<ID, int32_t> IDToWindowIndex;
        std::unordered_map<OSWindowHandle, int32_t> HandleToWindowIndex;
        
        std::unordered_set<ID> userClosedWindows;
 
        // ---------------- Internal ---------------- 
 
        Window* FindWindow(ID id)
        {
            int32_t index = IndexOf(id);
            if (index == -1) return nullptr;
            return &windows[index];
        }
 
        Window* FindWindow(OSWindowHandle handle)
        {
            int32_t index = IndexOf(handle);
            if (index == -1) return nullptr;
            return &windows[index];
        }
 
        int32_t IndexOf(ID id) const
        {
            if (id == ID::Invalid()) return -1;
            auto it = IDToWindowIndex.find(id);
            if (it == IDToWindowIndex.end()) return -1;
            return it->second;
        }
 
        int32_t IndexOf(OSWindowHandle handle) const
        {
            auto it = HandleToWindowIndex.find(handle);
            if (it == HandleToWindowIndex.end()) return -1;
            return it->second;
        }
 
        inline bool IsNotAlive(int32_t index) const
        {
            return index < 0 || index >= static_cast<int32_t>(windows.size()) ||
                    windows[index].state != WindowState::Alive;
        }
 
        int GetMonitorIndexForWindow(ID id) const
        {
            int index = IndexOf(id);
            return (index != -1) ? windows[index].monitorIndex : -1;
        }
 
        RequestCloseResult RequestClose(int32_t index);
        RequestCloseResult RequestClose(int32_t index, std::vector<ID> &detach_children);
        void RemoveWindowFromSiblingList(int32_t window_index);
        float QueryDisplayScale(OSWindowHandle handle) const;
        void RaisePopup(const Window& window);
        bool    MayFade(const Window& window) const;
        float   FadeProgress(const Window& window, uint32_t nowMs) const;
        IntRect FadeRect(const Window& window, float shown) const;
        bool    BeginFadeIn(Window& window, uint32_t nowMs);
        void    EndFadeOf(Window& window);
        void    AnimateFades();
        bool    m_reducedMotion = false;
        const Window* MainWindow() const;
        void LinkToParent(int32_t window_index, ID parentID);
        void ClearParentIDInChildren(int32_t window_index);
        void RemoveWindow(int32_t window_index);
 
    };

}