gui_window_backend.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <optional>
 
#include <stdint.h>
#include <string>
#include <string_view>
#include <vector>
#include <functional>
#include <span>
 
 
namespace tachyon
{
 
    // gui_core/windows/gui_window_flags.h
    enum class WindowFlags : uint32_t;
 
    // gui_core/input/gui_input_enums.h
    enum class KeyModifier  : uint8_t;
    enum class MouseButtons : uint8_t;
    enum class KeyAction    : uint8_t;
    enum class MouseAction  : uint8_t;
    enum class KeyCode      : uint32_t;
 
    // gui_core/style/gui_style.h
    enum class MouseCursor : uint8_t;
 
    class IPlatformInputHandler; // gui_core/input/gui_platform_input_handler.h
    class GraphicsContext;       // gui_core/graphics/gui_graphics_context.h
    struct ID;                   // gui_core/gui_id.h

    using OSWindowHandle = void*;
    
    struct MonitorInfo
    {
        IntRect rect;       
        IntRect workArea;   
        bool isPrimary = false;    
        float contentScale = 1.0f; 
        float refreshRate  = 0.0f; 
    };

    enum class WindowHitArea : uint8_t
    {
        Client,         
        Caption,        
        MaximizeButton, 
    };

    enum class WindowMode : uint8_t
    {
        Normal,               
        Minimized,
        Maximized,
        Fullscreen,           
        ExclusiveFullscreen,  
    };

    class IWindowContext
    {
    public:
        virtual ~IWindowContext() = default;

        virtual ID             GetID() const = 0;
        virtual OSWindowHandle GetWindowHandle() const = 0;

        virtual bool IsTransparent() const = 0;
        virtual void RenderWindowFrame(tachyon::GraphicsContext* graphicsContext, tachyon::IntRect rect, bool resizing) = 0;
        virtual void RecordWindowFrame(tachyon::GraphicsContext* graphicsContext, tachyon::IntRect rect) { RenderWindowFrame(graphicsContext, rect, false); }
        virtual void PresentWindowFrame() {}
        virtual void UpdateTransparentWindow(int2 /*screenPos*/) {}

        virtual bool ReadPixels(std::span<uint8_t> /*bgra*/) { return false; }
 
    };

    class IWindowBackend
    {
    public:
        IWindowBackend() {}
        
        virtual ~IWindowBackend() {}

        virtual OSWindowHandle CreateWindow(std::string_view title, int2 size, WindowFlags windowFlags, OSWindowHandle parentOSHandle) = 0;
        virtual OSWindowHandle CreateWindow(std::string_view title, IntRect rect, WindowFlags windowFlags, OSWindowHandle parentOSHandle) = 0;
        virtual bool DestroyWindow(OSWindowHandle) = 0;
 

        virtual void AttachInputHandlerToWindow(OSWindowHandle window, IPlatformInputHandler* inputHandler) = 0;
        virtual void AttachContextToWindow(OSWindowHandle window, IWindowContext* context) = 0;

        virtual void DetachWindowContext(OSWindowHandle) = 0;

        virtual bool IsWindow(OSWindowHandle) = 0;

        virtual IWindowContext* GetWindowContext(OSWindowHandle) = 0;

        virtual void BringToFront(OSWindowHandle) = 0;
        virtual OSWindowHandle GetWindowUnderMouse() = 0;
        virtual OSWindowHandle GetActiveWindow() = 0;
        virtual uint32_t GetFocusChangeCount() const = 0;

        virtual void PollEvents(std::function<void(OSWindowHandle, IWindowContext*)> cleanup) = 0;
        virtual int2 GetScreenMousePos() = 0;
        virtual MouseButtons GetMouseButtons() = 0;
        virtual float GetDoubleClickMilliseconds() { return 0.0f; }
        virtual bool PrefersReducedMotion() { return false; }
        virtual std::optional<color4b> ReadScreenPixel(int2 /*screenPos*/) { return std::nullopt; }
        virtual bool TakeCloseRequest(OSWindowHandle /*window*/) { return false; }
        
        virtual void SetCursor(MouseCursor cursor) = 0;

        virtual void SetTextInputArea(OSWindowHandle window, IntRect rect) = 0;

        virtual float GetWindowDisplayScale(OSWindowHandle window) = 0;

        virtual IntRect GetWindowPixelRect(OSWindowHandle window) = 0;

        virtual void SwapBuffers(OSWindowHandle) = 0;

        virtual IntRect GetWindowRect(OSWindowHandle) = 0;
        virtual int2 GetWindowPos(OSWindowHandle) = 0;
        virtual int2 GetWindowSize(OSWindowHandle) = 0;

        virtual void* GetNativeHandle(OSWindowHandle) = 0;

        virtual bool SetWindowRect(OSWindowHandle, const IntRect& clientRect) = 0;
        virtual void SetWindowVisible(OSWindowHandle, bool visible) = 0;
        virtual bool SetWindowCloaked(OSWindowHandle, bool /*cloaked*/) { return false; }

        virtual uint32_t ShowFade(OSWindowHandle /*window*/, IWindowContext* /*context*/, IntRect /*screenRect*/, float /*opacity*/) { return 0; }
        virtual void MoveFade(uint32_t /*fade*/, IntRect /*screenRect*/, float /*opacity*/) {}
        virtual void EndFade(uint32_t /*fade*/) {}

        virtual std::vector<MonitorInfo> GetMonitors() const = 0;
        virtual int GetMonitorAt(int2 pos) const = 0;
        virtual int GetMonitorFromWindow(OSWindowHandle handle) const = 0;

        virtual uint32_t GetTicks() const = 0;

        virtual void       SetWindowMode(OSWindowHandle, WindowMode) {}
        virtual WindowMode GetWindowMode(OSWindowHandle) const { return WindowMode::Normal; }

        virtual std::string GetPreferredLanguage() const { return {}; }

        virtual int32_t GetCursorSize() const { return 0; }

        virtual void SetGraphicsContext(GraphicsContext* graphicsContext) { m_graphicsContext = graphicsContext; }

        void SetWindowMovedCallback(std::function<void()> cb) { m_onWindowMoved = std::move(cb); }

        void SetHitTestCallback(std::function<WindowHitArea(OSWindowHandle, int2 screenPos)> cb) { m_hitTest = std::move(cb); }
        WindowHitArea HitTestWindow(OSWindowHandle window, int2 screenPos) const
        {
            return m_hitTest ? m_hitTest(window, screenPos) : WindowHitArea::Client;
        }
 
    protected:
        std::function<void()> m_onWindowMoved;
        std::function<WindowHitArea(OSWindowHandle, int2)> m_hitTest;
        GraphicsContext*      m_graphicsContext = nullptr;
 
    };

} // namespace tachyon