Window.hpp

#ifndef RAYLIB_CPP_INCLUDE_WINDOW_HPP_
#define RAYLIB_CPP_INCLUDE_WINDOW_HPP_
 
#include <span>
#include <string>
#include <string_view>
 
#include "./raylib.hpp"
#include "./RaylibException.hpp"
#include "./Vector2.hpp"
 
namespace raylib {
class Window {
 public:
    Window() {
        // Nothing.
    }
 
    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");
        }
    }
 
    bool ShouldClose() const {
        return ::WindowShouldClose();
    }
 
    void SetExitKey(int key) {
        ::SetExitKey(key);
    }
 
    void Close() {
        if (::IsWindowReady()) {
            ::CloseWindow();
        }
    }
 
    bool IsCursorOnScreen() const {
        return ::IsCursorOnScreen();
    }
 
    bool IsFullscreen() const {
        return ::IsWindowFullscreen();
    }
 
    bool IsHidden() const {
        return ::IsWindowHidden();
    }
 
    bool IsMinimized() const {
        return ::IsWindowMinimized();
    }
 
    bool IsMaximized() const {
        return ::IsWindowMaximized();
    }
 
    bool IsFocused() const {
        return ::IsWindowFocused();
    }
 
    bool IsResized() const {
        return ::IsWindowResized();
    }
 
    bool IsState(unsigned int flag) const {
        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));
    }
 
    Vector2 GetSize() const {
        return {static_cast<float>(GetWidth()), static_cast<float>(GetHeight())};
    }
 
    void* GetHandle() const {
        return ::GetWindowHandle();
    }
 
    Window& BeginDrawing() {
        ::BeginDrawing();
        return *this;
    }
 
    Window& EndDrawing() {
        ::EndDrawing();
        return *this;
    }
 
    int GetWidth() const {
        return ::GetScreenWidth();
    }
 
    int GetHeight() const {
        return ::GetScreenHeight();
    }
 
    int GetRenderWidth() const {
        return ::GetRenderWidth();
    }
 
    int GetRenderHeight() const {
        return ::GetRenderHeight();
    }
 
    Vector2 GetPosition() const {
        return ::GetWindowPosition();
    }
 
    Vector2 GetScaleDPI() const {
        return ::GetWindowScaleDPI();
    }
 
    void SetClipboardText(const std::string_view text) {
        ::SetClipboardText(text.data());
    }
 
    const std::string GetClipboardText() {
        return ::GetClipboardText();
    }
 
    Window& SetTargetFPS(int fps) {
        ::SetTargetFPS(fps);
        return *this;
    }
 
    int GetFPS() const {
        return ::GetFPS();
    }
 
    void DrawFPS(int posX = 10, int posY = 10) const {
        ::DrawFPS(posX, posY);
    }
 
    float GetFrameTime() const {
        return ::GetFrameTime();
    }
 
    double GetTime() const {
        return ::GetTime();
    }
 
    static bool IsReady() {
        return ::IsWindowReady();
    }
 
    void SetConfigFlags(unsigned int flags) {
        ::SetConfigFlags(flags);
    }
};
}  // namespace raylib
 
using RWindow = raylib::Window;
 
#endif  // RAYLIB_CPP_INCLUDE_WINDOW_HPP_