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 CursorBase;
 
// Forward decl
struct CursorRef;
 
// Forward decl
struct 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 CursorBase : Resource<SDL_Cursor*>
{
  using Resource::Resource;
 
  CursorBase(const Uint8* data,
             const Uint8* mask,
             int w,
             int h,
             int hot_x,
             int hot_y)
    : Resource(CheckError(SDL_CreateCursor(data, mask, w, h, hot_x, hot_y)))
  {
  }
 
  CursorBase(SurfaceBase& surface, int hot_x, int hot_y)
    : Resource(CheckError(SDL_CreateColorCursor(surface.get(), hot_x, hot_y)))
  {
  }
 
  CursorBase(SystemCursor id)
    : Resource(CheckError(SDL_CreateSystemCursor(id)))
  {
  }
};
 
struct CursorRef : CursorBase
{
  using CursorBase::CursorBase;
 
  constexpr CursorRef(const CursorRef& other)
    : CursorBase(other.get())
  {
  }
 
  constexpr CursorRef(CursorRef&& other)
    : CursorBase(other.release())
  {
  }
 
  constexpr ~CursorRef() = default;
 
  CursorRef& operator=(CursorRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_Cursor* newResource = {})
  {
    SDL_DestroyCursor(release(newResource));
  }
};
 
struct Cursor : CursorRef
{
  using CursorRef::CursorRef;
 
  constexpr explicit Cursor(SDL_Cursor* resource = {})
    : CursorRef(resource)
  {
  }
 
  constexpr Cursor(const Cursor& other) = delete;
 
  constexpr Cursor(Cursor&& other) = default;
 
  ~Cursor() { reset(); }
 
  Cursor& operator=(Cursor other)
  {
    reset(other.release());
    return *this;
  }
};
 
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 MouseWheelDirection = SDL_MouseWheelDirection;
 
constexpr MouseWheelDirection MOUSEWHEEL_NORMAL =
  SDL_MOUSEWHEEL_NORMAL; 
 
constexpr MouseWheelDirection MOUSEWHEEL_FLIPPED =
  SDL_MOUSEWHEEL_FLIPPED; 
 
using MouseButtonFlags = Uint32;
 
constexpr MouseButtonFlags ButtonMask(MouseButton button)
{
  return SDL_BUTTON_MASK(button);
}
 
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; 
 
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 WindowBase::WarpMouse(float x, float y)
{
  SDL_WarpMouseInWindow(get(), x, y);
}
 
inline void WarpMouse(float x, float y)
{
  CheckError(SDL_WarpMouseGlobal(x, y));
}
 
inline void WindowBase::SetRelativeMouseMode(bool enabled)
{
  CheckError(SDL_SetWindowRelativeMouseMode(get(), enabled));
}
 
inline bool WindowBase::GetRelativeMouseMode() const
{
  return SDL_GetWindowRelativeMouseMode(get());
}
 
inline void CaptureMouse(bool enabled)
{
  CheckError(SDL_CaptureMouse(enabled));
}
 
inline void SetCursor(CursorBase& cursor)
{
  CheckError(SDL_SetCursor(cursor.get()));
}
 
inline CursorRef GetCursor() { return SDL_GetCursor(); }
 
inline CursorRef GetDefaultCursor()
{
  return CheckError(SDL_GetDefaultCursor());
}
 
inline void ShowCursor() { CheckError(SDL_ShowCursor()); }
 
inline void HideCursor() { CheckError(SDL_HideCursor()); }
 
inline bool CursorVisible() { return SDL_CursorVisible(); }
 
} // namespace SDL
 
#endif /* SDL3PP_MOUSE_H_ */