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 CursorRef;
 
// Forward decl
struct Cursor;
 
using CursorShared = ResourceShared<Cursor>;
 
using CursorWeak = ResourceWeak<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 CursorRef : Resource<SDL_Cursor*>
{
  using Resource::Resource;
  static void reset(SDL_Cursor* resource) { SDL_DestroyCursor(resource); }
};
 
struct Cursor : ResourceUnique<CursorRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Cursor Create(const Uint8* data,
                       const Uint8* mask,
                       const SDL_Point& size,
                       const SDL_Point& hot)
  {
    return Cursor(
      CheckError(SDL_CreateCursor(data, mask, size.x, size.y, hot.x, hot.y)));
  }
 
  static Cursor CreateColor(SurfaceRef surface, const SDL_Point& hot)
  {
    return Cursor(
      CheckError(SDL_CreateColorCursor(surface.get(), hot.x, hot.y)));
  }
 
  static Cursor CreateSystem(SystemCursor id)
  {
    return Cursor(CheckError(SDL_CreateSystemCursor(id)));
  }
 
  void Destroy() { reset(); }
  CursorShared share();
 
};
 
 
inline CursorShared Cursor::share()
{
  return CursorShared(std::move(*this));
}
 
struct CursorUnsafe : ResourceUnsafe<CursorRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit CursorUnsafe(Cursor&& other)
    : CursorUnsafe(other.release())
  {
  }
};
 
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 WindowRef::WarpMouse(float x, float y)
{
  SDL_WarpMouseInWindow(get(), x, y);
}
 
inline void WarpMouse(float x, float y)
{
  CheckError(SDL_WarpMouseGlobal(x, y));
}
 
inline void WindowRef::SetRelativeMouseMode(bool enabled)
{
  CheckError(SDL_SetWindowRelativeMouseMode(get(), enabled));
}
 
inline bool WindowRef::GetRelativeMouseMode() const
{
  return SDL_GetWindowRelativeMouseMode(get());
}
 
inline void CaptureMouse(bool enabled)
{
  CheckError(SDL_CaptureMouse(enabled));
}
 
inline void SetCursor(CursorRef 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_ */