window_internal.h

#ifndef PIXELBULLET_WINDOW_INTERNAL_WINDOW_INTERNAL_H_
#define PIXELBULLET_WINDOW_INTERNAL_WINDOW_INTERNAL_H_
 
#include "pixelbullet/core/event.h"
 
#include "pixelbullet/image/bitmap.h"
#include "pixelbullet/input/input.h"
#include "pixelbullet/input/key_codes.h"
#include "pixelbullet/window/callback_adapter_internal.h"
#include "pixelbullet/window/window_chrome.h"
 
#include <glm/glm.hpp>
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
struct GLFWimage;
struct GLFWwindow;
 
namespace pixelbullet
{
class Filesystem;
class VirtualPath;
class Window;
struct WindowConfig;
namespace input
{
class InputState;
}
} // namespace pixelbullet
 
namespace pixelbullet::window_internal
{
struct WindowState
{
    GLFWwindow* window = nullptr;
    std::string title;
    unsigned int width = 0;
    unsigned int height = 0;
    std::function<void(pixelbullet::core::Event&)> event_callback;
    std::function<void(uint32_t)> framebuffer_resize_callback;
 
    bool fullscreen = false;
    bool focused = false;
    glm::ivec2 size{ 0, 0 };
    glm::ivec2 fullscreen_size{ 0, 0 };
    glm::ivec2 position{ 0, 0 };
    glm::vec2 content_scale{ 1.0f, 1.0f };
    pixelbullet::input::InputState input_state;
    uint32_t id = 0;
    bool cursor_capture_requested = false;
    bool cursor_captured = false;
    WindowFrameMode frame_mode = WindowFrameMode::SystemDecorated;
    bool custom_chrome_supported = false;
    bool custom_chrome_attached = false;
    WindowChromeLayout custom_chrome_layout{};
    WindowFrameActivity frame_activity{};
};
 
struct WindowSnapshot
{
    glm::ivec2 framebuffer_size{ 0, 0 };
    glm::ivec2 position{ 0, 0 };
    bool focused = false;
    glm::vec2 content_scale{ 1.0f, 1.0f };
};
 
class GlfwApi
{
public:
    virtual ~GlfwApi() = default;
 
    virtual void AcquireRuntime() = 0;
    virtual void ReleaseRuntime() noexcept = 0;
    [[nodiscard]] virtual unsigned int NextWindowId() noexcept = 0;
    virtual void DefaultWindowHints() = 0;
    virtual void WindowHint(int hint, int value) = 0;
    [[nodiscard]] virtual GLFWwindow* CreateWindow(int width, int height, const char* title) = 0;
    virtual void DestroyWindow(GLFWwindow* window) = 0;
    virtual void SetWindowUserPointer(GLFWwindow* window, void* pointer) = 0;
    [[nodiscard]] virtual WindowSnapshot CaptureWindowSnapshot(GLFWwindow* window) = 0;
    virtual void RegisterCallbacks(GLFWwindow* window) = 0;
    virtual void PollEvents() noexcept = 0;
    virtual void WaitEventsTimeout(double timeout_seconds) noexcept = 0;
    virtual void SetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images) = 0;
    virtual void IconifyWindow(GLFWwindow* window) noexcept = 0;
    virtual void MaximizeWindow(GLFWwindow* window) noexcept = 0;
    virtual void RestoreWindow(GLFWwindow* window) noexcept = 0;
    virtual void SetInputMode(GLFWwindow* window, int mode, int value) noexcept = 0;
    virtual void SetClipboardString(GLFWwindow* window, const char* text) noexcept = 0;
    [[nodiscard]] virtual const char* GetClipboardString(GLFWwindow* window) const noexcept = 0;
    [[nodiscard]] virtual int GetWindowAttrib(GLFWwindow* window, int attrib) const noexcept = 0;
    [[nodiscard]] virtual int GetKey(GLFWwindow* window, int key) const noexcept = 0;
    [[nodiscard]] virtual glm::vec2 GetCursorPos(GLFWwindow* window) const noexcept = 0;
};
 
class WindowChromeApi
{
public:
    virtual ~WindowChromeApi() = default;
 
    [[nodiscard]] virtual bool PlatformSupportsCustomChrome() const noexcept = 0;
    [[nodiscard]] virtual bool AttachCustomChrome(Window& window) = 0;
    virtual void DetachCustomChrome(Window& window) noexcept = 0;
    virtual void OnLayoutChanged(Window& window) noexcept = 0;
    virtual void ShowSystemMenuAt(Window& window, WindowPoint client_point) noexcept = 0;
    [[nodiscard]] virtual std::optional<bool> QueryNativeMaximized(const Window& window) const noexcept = 0;
};
 
struct WindowAccess
{
    [[nodiscard]] static GLFWwindow*& NativeWindow(Window& window) noexcept;
    [[nodiscard]] static const GLFWwindow* NativeWindow(const Window& window) noexcept;
    [[nodiscard]] static std::string& Title(Window& window) noexcept;
    [[nodiscard]] static unsigned int& Width(Window& window) noexcept;
    [[nodiscard]] static unsigned int& Height(Window& window) noexcept;
    [[nodiscard]] static bool& Focused(Window& window) noexcept;
    [[nodiscard]] static bool& Fullscreen(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& Size(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& FullscreenSize(Window& window) noexcept;
    [[nodiscard]] static glm::ivec2& Position(Window& window) noexcept;
    [[nodiscard]] static glm::vec2& ContentScale(Window& window) noexcept;
    [[nodiscard]] static pixelbullet::input::InputState& InputState(Window& window) noexcept;
    [[nodiscard]] static std::function<void(pixelbullet::core::Event&)>& EventCallback(Window& window) noexcept;
    [[nodiscard]] static std::function<void(uint32_t)>& FramebufferResizeCallback(Window& window) noexcept;
    [[nodiscard]] static uint32_t& Id(Window& window) noexcept;
    [[nodiscard]] static bool& CursorCaptureRequested(Window& window) noexcept;
    [[nodiscard]] static bool& CursorCaptured(Window& window) noexcept;
    [[nodiscard]] static WindowFrameMode& FrameMode(Window& window) noexcept;
    [[nodiscard]] static bool& CustomChromeSupported(Window& window) noexcept;
    [[nodiscard]] static bool& CustomChromeAttached(Window& window) noexcept;
    [[nodiscard]] static WindowChromeLayout& CustomChromeLayout(Window& window) noexcept;
    [[nodiscard]] static WindowFrameActivity& FrameActivity(Window& window) noexcept;
};
 
class ScopedGlfwApiOverride
{
public:
    explicit ScopedGlfwApiOverride(GlfwApi& api) noexcept;
    ~ScopedGlfwApiOverride();
 
    ScopedGlfwApiOverride(const ScopedGlfwApiOverride&) = delete;
    ScopedGlfwApiOverride& operator=(const ScopedGlfwApiOverride&) = delete;
 
private:
    GlfwApi* previous_api_ = nullptr;
};
 
class ScopedWindowChromeApiOverride
{
public:
    explicit ScopedWindowChromeApiOverride(WindowChromeApi& api) noexcept;
    ~ScopedWindowChromeApiOverride();
 
    ScopedWindowChromeApiOverride(const ScopedWindowChromeApiOverride&) = delete;
    ScopedWindowChromeApiOverride& operator=(const ScopedWindowChromeApiOverride&) = delete;
 
private:
    WindowChromeApi* previous_api_ = nullptr;
};
 
using IconBitmapLoader = std::function<Bitmap(const Filesystem&, const VirtualPath&)>;
 
class ScopedIconBitmapLoaderOverride
{
public:
    explicit ScopedIconBitmapLoaderOverride(IconBitmapLoader loader);
    ~ScopedIconBitmapLoaderOverride();
 
    ScopedIconBitmapLoaderOverride(const ScopedIconBitmapLoaderOverride&) = delete;
    ScopedIconBitmapLoaderOverride& operator=(const ScopedIconBitmapLoaderOverride&) = delete;
 
private:
    IconBitmapLoader previous_loader_;
};
 
[[nodiscard]] GlfwApi& GetGlfwApi();
[[nodiscard]] WindowChromeApi& GetWindowChromeApi();
[[nodiscard]] Bitmap LoadIconBitmap(const Filesystem& filesystem, const VirtualPath& icon_path);
 
void InitializeWindow(Window& window, const WindowConfig& config);
void ShutdownWindow(Window& window) noexcept;
void BeginFrame(Window& window) noexcept;
void PollEvents() noexcept;
void WaitEventsTimeout(double timeout_seconds) noexcept;
void SetIcon(Window& window, const Filesystem& filesystem, const VirtualPath& icon_path);
void Minimize(Window& window) noexcept;
void Maximize(Window& window) noexcept;
void Restore(Window& window) noexcept;
void RequestClose(Window& window) noexcept;
[[nodiscard]] bool SetClipboardText(Window& window, std::string_view text);
[[nodiscard]] std::optional<std::string> GetClipboardText(const Window& window);
void ShowSystemMenuAt(Window& window, WindowPoint client_point) noexcept;
[[nodiscard]] bool SupportsCustomChrome(const Window& window) noexcept;
void SetCustomChromeLayout(Window& window, const WindowChromeLayout& layout);
void ClearCustomChromeLayout(Window& window);
void SetCursorCaptured(Window& window, bool captured) noexcept;
void HandleFocusChanged(Window& window, bool focused) noexcept;
[[nodiscard]] bool IsKeyDown(const Window& window, pixelbullet::input::KeyCode key) noexcept;
[[nodiscard]] bool IsMinimized(const Window& window) noexcept;
[[nodiscard]] bool IsMaximized(const Window& window) noexcept;
[[nodiscard]] const WindowFrameActivity& GetFrameActivity(Window& window) noexcept;
} // namespace pixelbullet::window_internal
 
#endif // PIXELBULLET_WINDOW_INTERNAL_WINDOW_INTERNAL_H_