Window.hpp

#ifndef RAYLIB_CPP_INCLUDE_WINDOW_HPP_
#define RAYLIB_CPP_INCLUDE_WINDOW_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./RaylibException.hpp"
#include "./Vector2.hpp"
#include "./raylib.hpp"
 
namespace raylib {
class Window {
public:
    Window() = default;
 
    Window(int width, int height, const std::string_view title = "raylib", unsigned int flags = 0) {
        Init(width, height, title, flags);
    }
 
    ~Window() { Close(); }
 
    void Init(int width = 800, int height = 450, const std::string_view title = "raylib", unsigned int flags = 0) {
        if (flags != 0) {
            ::SetConfigFlags(flags);
        }
        ::InitWindow(width, height, title.data());
        if (!::IsWindowReady()) {
            throw RaylibException("Failed to create Window");
        }
    }
 
    static bool ShouldClose()  { return ::WindowShouldClose(); }
 
    static void SetExitKey(int key) { ::SetExitKey(key); }
 
    static void Close() {
        if (::IsWindowReady()) {
            ::CloseWindow();
        }
    }
 
    static bool IsCursorOnScreen()  { return ::IsCursorOnScreen(); }
 
    static bool IsCursorHidden()  { return ::IsCursorHidden(); }
 
    static void HideCursor()  { ::HideCursor(); }
 
    static void ShowCursor()  { ::ShowCursor(); }
 
    static bool IsFullscreen()  { return ::IsWindowFullscreen(); }
 
    static bool IsHidden()  { return ::IsWindowHidden(); }
 
    static bool IsMinimized()  { return ::IsWindowMinimized(); }
 
    static bool IsMaximized()  { return ::IsWindowMaximized(); }
 
    static bool IsFocused()  { return ::IsWindowFocused(); }
 
    static bool IsResized()  { return ::IsWindowResized(); }
 
    static bool IsState(unsigned int flag)  { return ::IsWindowState(flag); }
 
    Window& SetState(unsigned int flag) {
        ::SetWindowState(flag);
        return *this;
    }
 
    Window& ClearState(unsigned int flag) {
        ::ClearWindowState(flag);
        return *this;
    }
 
    Window& ClearBackground(const ::Color& color = BLACK) {
        ::ClearBackground(color);
        return *this;
    }
 
    Window& ToggleFullscreen() {
        ::ToggleFullscreen();
        return *this;
    }
 
    Window& SetFullscreen(bool fullscreen) {
        if (fullscreen) {
            if (!IsFullscreen()) {
                ToggleFullscreen();
            }
        }
        else {
            if (IsFullscreen()) {
                ToggleFullscreen();
            }
        }
 
        return *this;
    }
 
    Window& ToggleBorderless() {
        ::ToggleBorderlessWindowed();
        return *this;
    }
 
    Window& Maximize() {
        ::MaximizeWindow();
        return *this;
    }
 
    Window& Minimize() {
        ::MinimizeWindow();
        return *this;
    }
 
    Window& Restore() {
        ::RestoreWindow();
        return *this;
    }
 
    Window& SetIcon(const ::Image& image) {
        ::SetWindowIcon(image);
        return *this;
    }
 
    Window& SetIcons(Image* images, int count) {
        ::SetWindowIcons(images, count);
        return *this;
    }
 
    Window& SetIcons(std::span<Image> images) {
        ::SetWindowIcons(images.data(), static_cast<int>(images.size()));
        return *this;
    }
 
    Window& SetTitle(const std::string_view title) {
        ::SetWindowTitle(title.data());
        return *this;
    }
 
    Window& SetPosition(int x, int y) {
        ::SetWindowPosition(x, y);
        return *this;
    }
 
    Window& SetPosition(const ::Vector2& position) {
        return SetPosition(static_cast<int>(position.x), static_cast<int>(position.y));
    }
 
    Window& SetMonitor(int monitor) {
        ::SetWindowMonitor(monitor);
        return *this;
    }
 
    Window& SetMinSize(int width, int height) {
        ::SetWindowMinSize(width, height);
        return *this;
    }
 
    Window& SetMinSize(const ::Vector2& size) {
        ::SetWindowMinSize(static_cast<int>(size.x), static_cast<int>(size.y));
        return *this;
    }
 
    Window& SetSize(int width, int height) {
        ::SetWindowSize(width, height);
        return *this;
    }
 
    Window& SetOpacity(float opacity) {
        ::SetWindowOpacity(opacity);
        return *this;
    }
 
    Window& SetFocused() {
        ::SetWindowFocused();
        return *this;
    }
 
    Window& SetSize(const ::Vector2& size) { return SetSize(static_cast<int>(size.x), static_cast<int>(size.y)); }
 
    static Vector2 GetSize() { return {static_cast<float>(GetWidth()), static_cast<float>(GetHeight())}; }
 
    static void* GetHandle() { return ::GetWindowHandle(); }
 
    Window& BeginDrawing() {
        ::BeginDrawing();
        return *this;
    }
 
    Window& EndDrawing() {
        ::EndDrawing();
        return *this;
    }
 
    static int GetWidth() { return ::GetScreenWidth(); }
 
    static int GetHeight() { return ::GetScreenHeight(); }
 
    static int GetRenderWidth() { return ::GetRenderWidth(); }
 
    static int GetRenderHeight() { return ::GetRenderHeight(); }
 
    static Vector2 GetPosition() { return ::GetWindowPosition(); }
 
    /*
     * Get current window monitor
     */
    static int GetMonitor() { return ::GetCurrentMonitor(); }
 
    static Vector2 GetScaleDPI() { return ::GetWindowScaleDPI(); }
 
    void SetClipboardText(const std::string_view text) {
        ::SetClipboardText(text.data());
    }
 
    static std::string GetClipboardText() { return ::GetClipboardText(); }
 
    Window& SetTargetFPS(int fps) {
        ::SetTargetFPS(fps);
        return *this;
    }
 
    static int GetFPS()  { return ::GetFPS(); }
 
    static void DrawFPS(int posX = 10, int posY = 10)  { ::DrawFPS(posX, posY); }
 
    static float GetFrameTime()  { return ::GetFrameTime(); }
 
    static double GetTime()  { return ::GetTime(); }
 
    static bool IsValid() { return ::IsWindowReady(); }
 
    static void SetConfigFlags(unsigned int flags) { ::SetConfigFlags(flags); }
 
    bool Drawing() {
        if (m_drawing) {
            EndDrawing();
            m_drawing = false;
        }
        else {
            BeginDrawing();
            m_drawing = true;
        }
 
        return m_drawing;
    }
 
    protected:
        bool m_drawing = false;
};
} // namespace raylib
 
using RWindow = raylib::Window;
 
#endif // RAYLIB_CPP_INCLUDE_WINDOW_HPP_