SDL3pp_keyboard.h

#ifndef SDL3PP_KEYBOARD_H_
#define SDL3PP_KEYBOARD_H_
 
#include <SDL3/SDL_keyboard.h>
#include "SDL3pp_keycode.h"
#include "SDL3pp_scancode.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_video.h"
 
namespace SDL {


using KeyboardID = SDL_KeyboardID;

inline bool HasKeyboard() { return SDL_HasKeyboard(); }

inline OwnArray<KeyboardID> GetKeyboards()
{
  int count;
  auto data = CheckError(SDL_GetKeyboards(&count));
  return OwnArray<KeyboardID>{data, size_t(count)};
}

inline const char* GetKeyboardNameForID(KeyboardID instance_id)
{
  return SDL_GetKeyboardNameForID(instance_id);
}

inline WindowRef GetKeyboardFocus() { return {SDL_GetKeyboardFocus()}; }

inline std::span<const bool> GetKeyboardState()
{
  int count;
  auto data = SDL_GetKeyboardState(&count);
  return std::span{data, size_t(count)};
}

inline void ResetKeyboard() { SDL_ResetKeyboard(); }

inline Keymod GetModState() { return SDL_GetModState(); }

inline void SetModState(Keymod modstate) { SDL_SetModState(modstate); }
 
inline Keycode::Keycode(Scancode scancode, Keymod modstate, bool key_event)
  : m_keycode(SDL_GetKeyFromScancode(scancode, modstate, key_event))
{
}
 
inline Keycode::Keycode(StringParam name)
  : m_keycode(SDL_GetKeyFromName(name))
{
}

inline Keycode GetKeyFromScancode(Scancode scancode,
                                  Keymod modstate,
                                  bool key_event)
{
  return SDL_GetKeyFromScancode(scancode, modstate, key_event);
}

inline Scancode GetScancodeFromKey(Keycode key, Keymod* modstate = nullptr)
{
  return SDL_GetScancodeFromKey(key, modstate);
}
 
inline Scancode Keycode::GetScancode(Keymod* modstate) const
{
  return SDL_GetScancodeFromKey(m_keycode, modstate);
}

inline void SetScancodeName(Scancode scancode, StringParam name)
{
  CheckError(SDL_SetScancodeName(scancode, name));
}
 
inline void Scancode::SetName(StringParam name)
{
  CheckError(SDL_SetScancodeName(m_scancode, name));
}

inline const char* GetScancodeName(Scancode scancode)
{
  return SDL_GetScancodeName(scancode);
}
 
inline const char* Scancode::GetName() const
{
  return SDL_GetScancodeName(m_scancode);
}

inline Scancode GetScancodeFromName(StringParam name)
{
  return SDL_GetScancodeFromName(name);
}
 
inline Scancode::Scancode(StringParam name)
  : m_scancode(SDL_GetScancodeFromName(name))
{
}

inline const char* GetKeyName(Keycode key) { return SDL_GetKeyName(key); }
 
inline const char* Keycode::GetName() const
{
  return SDL_GetKeyName(m_keycode);
}

inline Keycode GetKeyFromName(StringParam name)
{
  return SDL_GetKeyFromName(name);
}

inline void StartTextInput(WindowRef window)
{
  CheckError(SDL_StartTextInput(window));
}
 
inline void WindowBase::StartTextInput() { SDL::StartTextInput(get()); }

using TextInputType = SDL_TextInputType;
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT =
  SDL_TEXTINPUT_TYPE_TEXT; 
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT_NAME =
  SDL_TEXTINPUT_TYPE_TEXT_NAME; 
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT_EMAIL =
  SDL_TEXTINPUT_TYPE_TEXT_EMAIL; 
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT_USERNAME =
  SDL_TEXTINPUT_TYPE_TEXT_USERNAME; 
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN =
  SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN; 
 
constexpr TextInputType TEXTINPUT_TYPE_TEXT_PASSWORD_VISIBLE =
  SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_VISIBLE; 
 
constexpr TextInputType TEXTINPUT_TYPE_NUMBER =
  SDL_TEXTINPUT_TYPE_NUMBER; 
 
constexpr TextInputType TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN =
  SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN; 
 
constexpr TextInputType TEXTINPUT_TYPE_NUMBER_PASSWORD_VISIBLE =
  SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_VISIBLE; 

using Capitalization = SDL_Capitalization;
 
constexpr Capitalization CAPITALIZE_NONE =
  SDL_CAPITALIZE_NONE; 
 
constexpr Capitalization CAPITALIZE_SENTENCES =
  SDL_CAPITALIZE_SENTENCES; 
 
constexpr Capitalization CAPITALIZE_WORDS =
  SDL_CAPITALIZE_WORDS; 
 
constexpr Capitalization CAPITALIZE_LETTERS =
  SDL_CAPITALIZE_LETTERS; 

inline void StartTextInputWithProperties(WindowRef window, PropertiesRef props)
{
  CheckError(SDL_StartTextInputWithProperties(window, props));
}
 
inline void WindowBase::StartTextInputWithProperties(PropertiesRef props)
{
  SDL::StartTextInputWithProperties(get(), props);
}

namespace prop::TextInput {

constexpr auto TYPE_NUMBER = SDL_PROP_TEXTINPUT_TYPE_NUMBER;

constexpr auto CAPITALIZATION_NUMBER = SDL_PROP_TEXTINPUT_CAPITALIZATION_NUMBER;
 
constexpr auto AUTOCORRECT_BOOLEAN =
  SDL_PROP_TEXTINPUT_AUTOCORRECT_BOOLEAN; 
 
constexpr auto MULTILINE_BOOLEAN =
  SDL_PROP_TEXTINPUT_MULTILINE_BOOLEAN; 
 
constexpr auto ANDROID_INPUTTYPE_NUMBER =
  SDL_PROP_TEXTINPUT_ANDROID_INPUTTYPE_NUMBER; 
 
} // namespace prop::TextInput

inline bool TextInputActive(WindowRef window)
{
  return SDL_TextInputActive(window);
}
 
inline bool WindowBase::IsTextInputActive() const
{
  return TextInputActive(get());
}

inline void StopTextInput(WindowRef window)
{
  CheckError(SDL_StopTextInput(window));
}
 
inline void WindowBase::StopTextInput() { SDL::StopTextInput(get()); }

inline void ClearComposition(WindowRef window)
{
  CheckError(SDL_ClearComposition(window));
}
 
inline void WindowBase::ClearComposition() { SDL::ClearComposition(get()); }

inline void SetTextInputArea(WindowRef window, const RectRaw& rect, int cursor)
{
  CheckError(SDL_SetTextInputArea(window, &rect, cursor));
}
 
inline void WindowBase::SetTextInputArea(const RectRaw& rect, int cursor)
{
  SDL::SetTextInputArea(get(), rect, cursor);
}

inline void GetTextInputArea(WindowRef window, RectRaw* rect, int* cursor)
{
  CheckError(SDL_GetTextInputArea(window, rect, cursor));
}
 
inline void WindowBase::GetTextInputArea(RectRaw* rect, int* cursor) const
{
  SDL::GetTextInputArea(get(), rect, cursor);
}

inline bool HasScreenKeyboardSupport()
{
  return SDL_HasScreenKeyboardSupport();
}

inline bool ScreenKeyboardShown(WindowRef window)
{
  return SDL_ScreenKeyboardShown(window);
}
 
inline bool WindowBase::IsScreenKeyboardShown() const
{
  return ScreenKeyboardShown(get());
}

 
} // namespace SDL
 
#endif /* SDL3PP_KEYBOARD_H_ */