gui_window_backend_sdl.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/gui_base_types.h>
#include <gui_core/windows/gui_window_backend.h>
#include <gui_core/windows/gui_layered_fade.h>
#include <gui_core/input/gui_input_enums.h>
#include <gui_core/memory/gui_allocation_hooks.h>
 
#include <vector>
#include <unordered_set>
#include <unordered_map>
 
struct SDL_Window;
struct SDL_Cursor;
union SDL_Event;
 
namespace tachyon
{
 
    class GraphicsContext;
 
    // Outside the class: GCC can't use a nested struct's member initializers in a default
    // argument of the class being defined.
    struct SDLWindowBackendOptions
    {
        const AllocationHooks* hooks = nullptr;
        bool pumpEvents = true;
    };

    class SDLWindowBackend : public IWindowBackend
    {
    public:
        using Options = SDLWindowBackendOptions;

        explicit SDLWindowBackend(const Options& options = {});
        ~SDLWindowBackend() override;

        void SetGraphicsContext(GraphicsContext* graphicsContext) override;
 
        // IWindowBackend
        OSWindowHandle CreateWindow(std::string_view title, int2 size, tachyon::WindowFlags windowFlags, OSWindowHandle parentOSHandle) override;
        OSWindowHandle CreateWindow(std::string_view title, IntRect rect, tachyon::WindowFlags windowFlags, OSWindowHandle parentOSHandle) override;
 
 
        void AttachInputHandlerToWindow(OSWindowHandle window, IPlatformInputHandler* inputHandler) override;
        void AttachContextToWindow(OSWindowHandle window, IWindowContext* context) override;
 
        bool DestroyWindow(OSWindowHandle) override;
        void DetachWindowContext(OSWindowHandle) override;
        bool IsWindow(OSWindowHandle) override;
 
        IWindowContext* GetWindowContext(OSWindowHandle) override;
 
        void BringToFront(OSWindowHandle) override;
        OSWindowHandle GetWindowUnderMouse() override;
        OSWindowHandle GetActiveWindow() override;
        uint32_t GetFocusChangeCount() const override { return m_focusChanges; }
 
        void PollEvents(std::function<void(OSWindowHandle, IWindowContext*)> cleanup) override;
        int2 GetScreenMousePos() override;
        std::optional<color4b> ReadScreenPixel(int2 screenPos) override;
        bool TakeCloseRequest(OSWindowHandle window) override;
        MouseButtons GetMouseButtons() override;
        float GetDoubleClickMilliseconds() override;
        uint32_t ShowFade(OSWindowHandle window, IWindowContext* context, IntRect screenRect, float opacity) override;
        void     MoveFade(uint32_t fade, IntRect screenRect, float opacity) override;
        void     EndFade(uint32_t fade) override;
        bool PrefersReducedMotion() override;
        
        void SetCursor(MouseCursor cursor) override;
        void SetTextInputArea(OSWindowHandle window, IntRect rect) override;
        float GetWindowDisplayScale(OSWindowHandle window) override;
        IntRect GetWindowPixelRect(OSWindowHandle window) override;
 
        void SwapBuffers(OSWindowHandle) override;
 
        IntRect GetWindowRect(OSWindowHandle) override;
        int2 GetWindowPos(OSWindowHandle) override;
        int2 GetWindowSize(OSWindowHandle) override;
 
        bool SetWindowRect(OSWindowHandle, const IntRect& clientRect) override;
        void SetWindowVisible(OSWindowHandle, bool visible) override;
        bool SetWindowCloaked(OSWindowHandle, bool cloaked) override;
        void       SetWindowMode(OSWindowHandle, WindowMode) override;
        WindowMode GetWindowMode(OSWindowHandle) const override;
 
        std::vector<MonitorInfo> GetMonitors() const override;
        int GetMonitorAt(int2 pos) const override;
        int GetMonitorFromWindow(OSWindowHandle handle) const override;
 
        // Platform-specific operations
        uint32_t GetTicks() const override;
        std::string GetPreferredLanguage() const override;
        int32_t     GetCursorSize() const override;
        
        void* GetNativeHandle(OSWindowHandle) override;

        static SDL_Window* ToSDL(OSWindowHandle h) { return reinterpret_cast<SDL_Window*>(h); }
        static OSWindowHandle FromSDL(SDL_Window* w) { return reinterpret_cast<OSWindowHandle>(w); }
 
    private:
        void UpdateMouseState();
 
        Options m_options;
 
        std::unordered_set<SDL_Window*> m_windows;
        std::vector<SDL_Window*> m_modalWindows;
        int2 m_mousePos{};

        float OsPerPixel(SDL_Window* window) const;
    public:
        int2  WindowPointToPixels(SDL_Window* window, float x, float y) const;
    private:
        MouseButtons m_mouseButtons = MouseButtons::None;

        std::unordered_set<SDL_Window*> m_pendingDestroy;
        std::unordered_set<SDL_Window*> m_closeRequests;   
        bool m_sdlInitialized = false;
        bool m_ownsSDL        = false; 
        bool m_routesSDLMemory = false; 
        bool m_cursorVisible = true;
        static constexpr int kSystemCursorSlots = 32;
        SDL_Cursor* m_systemCursors[kSystemCursorSlots] = {};
        bool (*m_eventWatch)(void*, SDL_Event*) = nullptr;
        static bool BackendEventWatch(void* userdata, SDL_Event* event);
        uint32_t m_focusChanges = 0;
        bool m_checkFocusLeftApp = false;  
        bool m_suppressLiveResize = false; 
        SDL_Window* m_lastFocusableWindow = nullptr; 
        LayeredFades m_fades;               
        
        SDL_Window* GetTopModalWindowSDL() const;
    public:
        SDL_Window* ModalBlockerFor(const SDL_Event* event) const;
    private:
    };

} // namespace tachyon