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*;

using CursorRef = ResourceRef<Cursor>;

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;

struct Cursor : ResourceBase<CursorRaw>
{
  using ResourceBase::ResourceBase;

  constexpr explicit Cursor(CursorRaw resource) noexcept
    : ResourceBase(resource)
  {
  }

  constexpr Cursor(const Cursor& other) = delete;

  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);

  Cursor(SurfaceRef surface, const PointRaw& hot);

  Cursor(SystemCursor id);

  ~Cursor() { SDL_DestroyCursor(get()); }

  constexpr Cursor& operator=(Cursor&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Cursor& operator=(const Cursor& other) = delete;

  void Destroy();

  void Set();
};

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 CheckError(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(get(), 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(get(), enabled));
}
 
inline bool Window::GetRelativeMouseMode() const
{
  return SDL_GetWindowRelativeMouseMode(get());
}

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::Cursor(const Uint8* data,
                      const Uint8* mask,
                      const PointRaw& size,
                      const PointRaw& hot)
  : Cursor(
      CheckError(SDL_CreateCursor(data, mask, size.x, size.y, hot.x, hot.y)))
{
}
 
inline Cursor::Cursor(SurfaceRef surface, const PointRaw& hot)
  : Cursor(CheckError(SDL_CreateColorCursor(surface, hot.x, hot.y)))
{
}
 
inline Cursor::Cursor(SystemCursor id)
  : Cursor(CheckError(SDL_CreateSystemCursor(id)))
{
}

inline Cursor CreateColorCursor(SurfaceRef 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(CursorRef cursor) { CheckError(SDL_SetCursor(cursor)); }
 
inline void Cursor::Set() { SDL::SetCursor(get()); }

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_ */