SDL3pp_mouse.h

#ifndef SDL3PP_MOUSE_H_
#define SDL3PP_MOUSE_H_
 
#include <SDL3/SDL_mouse.h>
#include "SDL3pp_stdinc.h"
#include "SDL3pp_video.h"
 
namespace SDL {
 
// Forward decl
struct Cursor;
 
using CursorRaw = SDL_Cursor*;
 
// Forward decl
struct CursorRef;
 
struct CursorParam
{
  CursorRaw value; 
 
  constexpr CursorParam(CursorRaw value)
    : value(value)
  {
  }
 
  constexpr CursorParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const CursorParam& other) const = default;
 
  constexpr operator CursorRaw() const { return value; }
};
 
using SystemCursor = SDL_SystemCursor;
 
constexpr SystemCursor SYSTEM_CURSOR_DEFAULT =
  SDL_SYSTEM_CURSOR_DEFAULT; 
 
constexpr SystemCursor SYSTEM_CURSOR_TEXT =
  SDL_SYSTEM_CURSOR_TEXT; 
 
constexpr SystemCursor SYSTEM_CURSOR_WAIT = SDL_SYSTEM_CURSOR_WAIT;
 
constexpr SystemCursor SYSTEM_CURSOR_CROSSHAIR =
  SDL_SYSTEM_CURSOR_CROSSHAIR; 
 
constexpr SystemCursor SYSTEM_CURSOR_PROGRESS = SDL_SYSTEM_CURSOR_PROGRESS;
 
constexpr SystemCursor SYSTEM_CURSOR_NWSE_RESIZE =
  SDL_SYSTEM_CURSOR_NWSE_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_NESW_RESIZE =
  SDL_SYSTEM_CURSOR_NESW_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_EW_RESIZE =
  SDL_SYSTEM_CURSOR_EW_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_NS_RESIZE =
  SDL_SYSTEM_CURSOR_NS_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_MOVE = SDL_SYSTEM_CURSOR_MOVE;
 
constexpr SystemCursor SYSTEM_CURSOR_NOT_ALLOWED =
  SDL_SYSTEM_CURSOR_NOT_ALLOWED;
 
constexpr SystemCursor SYSTEM_CURSOR_POINTER = SDL_SYSTEM_CURSOR_POINTER;
 
constexpr SystemCursor SYSTEM_CURSOR_NW_RESIZE = SDL_SYSTEM_CURSOR_NW_RESIZE;
 
constexpr SystemCursor SYSTEM_CURSOR_N_RESIZE =
  SDL_SYSTEM_CURSOR_N_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_NE_RESIZE =
  SDL_SYSTEM_CURSOR_NE_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_E_RESIZE =
  SDL_SYSTEM_CURSOR_E_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_SE_RESIZE =
  SDL_SYSTEM_CURSOR_SE_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_S_RESIZE =
  SDL_SYSTEM_CURSOR_S_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_SW_RESIZE =
  SDL_SYSTEM_CURSOR_SW_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_W_RESIZE =
  SDL_SYSTEM_CURSOR_W_RESIZE; 
 
constexpr SystemCursor SYSTEM_CURSOR_COUNT = SDL_SYSTEM_CURSOR_COUNT; 
 
using MouseID = SDL_MouseID;
 
class Cursor
{
  CursorRaw m_resource = nullptr;
 
public:
  constexpr Cursor(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Cursor(const CursorRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Cursor(const Cursor& other) noexcept = default;
 
public:
  constexpr Cursor(Cursor&& other) noexcept
    : Cursor(other.release())
  {
  }
 
  constexpr Cursor(const CursorRef& other) = delete;
 
  constexpr Cursor(CursorRef&& other) = delete;
 
  Cursor(const Uint8* data,
         const Uint8* mask,
         const PointRaw& size,
         const PointRaw& hot)
    : m_resource(
        CheckError(SDL_CreateCursor(data, mask, size.x, size.y, hot.x, hot.y)))
  {
  }
 
  Cursor(SurfaceParam surface, const PointRaw& hot)
    : m_resource(CheckError(SDL_CreateColorCursor(surface, hot.x, hot.y)))
  {
  }
 
  Cursor(SystemCursor id)
    : m_resource(CheckError(SDL_CreateSystemCursor(id)))
  {
  }
 
  ~Cursor() { SDL_DestroyCursor(m_resource); }
 
  constexpr Cursor& operator=(Cursor&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Cursor& operator=(const Cursor& other) noexcept = default;
 
public:
  constexpr CursorRaw get() const noexcept { return m_resource; }
 
  constexpr CursorRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const Cursor& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator CursorParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  void Set();
};
 
struct CursorRef : Cursor
{
  using Cursor::Cursor;
 
  CursorRef(CursorParam resource) noexcept
    : Cursor(resource.value)
  {
  }
 
  CursorRef(CursorRaw resource) noexcept
    : Cursor(resource)
  {
  }
 
  constexpr CursorRef(const CursorRef& other) noexcept = default;
 
  ~CursorRef() { release(); }
};
 
using MouseWheelDirection = SDL_MouseWheelDirection;
 
constexpr MouseWheelDirection MOUSEWHEEL_NORMAL =
  SDL_MOUSEWHEEL_NORMAL; 
 
constexpr MouseWheelDirection MOUSEWHEEL_FLIPPED =
  SDL_MOUSEWHEEL_FLIPPED; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
using CursorFrameInfo = SDL_CursorFrameInfo;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
using MouseButton = Uint8;
 
constexpr MouseButton BUTTON_LEFT = SDL_BUTTON_LEFT; 
 
constexpr MouseButton BUTTON_MIDDLE = SDL_BUTTON_MIDDLE; 
 
constexpr MouseButton BUTTON_RIGHT = SDL_BUTTON_RIGHT; 
 
constexpr MouseButton BUTTON_X1 = SDL_BUTTON_X1; 
 
constexpr MouseButton BUTTON_X2 = SDL_BUTTON_X2; 
 
using MouseButtonFlags = Uint32;
 
constexpr MouseButtonFlags BUTTON_LMASK = SDL_BUTTON_LMASK; 
 
constexpr MouseButtonFlags BUTTON_MMASK = SDL_BUTTON_MMASK; 
 
constexpr MouseButtonFlags BUTTON_RMASK = SDL_BUTTON_RMASK; 
 
constexpr MouseButtonFlags BUTTON_X1MASK = SDL_BUTTON_X1MASK; 
 
constexpr MouseButtonFlags BUTTON_X2MASK = SDL_BUTTON_X2MASK; 
 
constexpr MouseButtonFlags ButtonMask(MouseButton button)
{
  return SDL_BUTTON_MASK(button);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
using MouseMotionTransformCallback = void(SDLCALL*)(void* userdata,
                                                    Uint64 timestamp,
                                                    WindowRaw window,
                                                    MouseID mouseID,
                                                    float* x,
                                                    float* y);
 
using MouseMotionTransformCB = MakeFrontCallback<void(Uint64 timestamp,
                                                      WindowRaw window,
                                                      MouseID mouseID,
                                                      float* x,
                                                      float* y)>;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline bool HasMouse() { return SDL_HasMouse(); }
 
inline OwnArray<MouseID> GetMice()
{
  int count;
  auto data = CheckError(SDL_GetMice(&count));
  return OwnArray<MouseID>{data, size_t(count)};
}
 
inline const char* GetMouseNameForID(MouseID instance_id)
{
  return SDL_GetMouseNameForID(instance_id);
}
 
inline WindowRef GetMouseFocus() { return {SDL_GetMouseFocus()}; }
 
inline MouseButtonFlags GetMouseState(float* x, float* y)
{
  return SDL_GetMouseState(x, y);
}
 
inline MouseButtonFlags GetGlobalMouseState(float* x, float* y)
{
  return SDL_GetGlobalMouseState(x, y);
}
 
inline MouseButtonFlags GetRelativeMouseState(float* x, float* y)
{
  return SDL_GetRelativeMouseState(x, y);
}
 
inline void Window::WarpMouse(const FPointRaw& p)
{
  SDL_WarpMouseInWindow(m_resource, p.x, p.y);
}
 
inline void WarpMouse(const FPointRaw& p)
{
  CheckError(SDL_WarpMouseGlobal(p.x, p.y));
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void SetRelativeMouseTransform(MouseMotionTransformCallback callback,
                                      void* userdata)
{
  CheckError(SDL_SetRelativeMouseTransform(callback, userdata));
}
 
inline void SetRelativeMouseTransform(MouseMotionTransformCB callback)
{
  SetRelativeMouseTransform(callback.wrapper, callback.data);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline void Window::SetRelativeMouseMode(bool enabled)
{
  CheckError(SDL_SetWindowRelativeMouseMode(m_resource, enabled));
}
 
inline bool Window::GetRelativeMouseMode() const
{
  return SDL_GetWindowRelativeMouseMode(m_resource);
}
 
inline void CaptureMouse(bool enabled)
{
  CheckError(SDL_CaptureMouse(enabled));
}
 
inline Cursor CreateCursor(const Uint8* data,
                           const Uint8* mask,
                           const PointRaw& size,
                           const PointRaw& hot)
{
  return Cursor(data, mask, size, hot);
}
 
inline Cursor CreateColorCursor(SurfaceParam surface, const PointRaw& hot)
{
  return Cursor(surface, hot);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline CursorRef CreateAnimatedCursor(CursorFrameInfo* frames,
                                      int frame_count,
                                      int hot_x,
                                      int hot_y)
{
  return CheckError(
    SDL_CreateAnimatedCursor(frames, frame_count, hot_x, hot_y));
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline Cursor CreateSystemCursor(SystemCursor id) { return Cursor(id); }
 
inline void SetCursor(CursorParam cursor) { CheckError(SDL_SetCursor(cursor)); }
 
inline void Cursor::Set() { SDL::SetCursor(m_resource); }
 
inline CursorRef GetCursor() { return {SDL_GetCursor()}; }
 
inline CursorRef GetDefaultCursor()
{
  return {CheckError(SDL_GetDefaultCursor())};
}
 
inline void DestroyCursor(CursorRaw cursor) { SDL_DestroyCursor(cursor); }
 
inline void Cursor::Destroy() { DestroyCursor(release()); }
 
inline void ShowCursor() { CheckError(SDL_ShowCursor()); }
 
inline void HideCursor() { CheckError(SDL_HideCursor()); }
 
inline bool CursorVisible() { return SDL_CursorVisible(); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_MOUSE_H_ */