SDL3pp_ttf.h

#ifndef SDL3PP_TTF_H_
#define SDL3PP_TTF_H_
 
#include "SDL3pp_gpu.h"
#include "SDL3pp_render.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_version.h"
#include "SDL3pp_video.h"
 
#if defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#include <SDL3_ttf/SDL_ttf.h>
 
namespace SDL {

 
// Forward decl
struct FontBase;
 
// Forward decl
struct Font;

using FontRaw = TTF_Font*;

using FontRef = ResourceRefT<FontBase>;
 
// Forward decl
struct TextEngine;

using TextEngineRaw = TTF_TextEngine*;

using TextEngineRef = ResourceRefT<TextEngine>;
 
// Forward decl
struct TextBase;
 
// Forward decl
struct Text;

using TextRaw = TTF_Text*;

using TextRawConst = const TTF_Text*;

using TextRef = ResourceRefT<TextBase>;

using TextConstRef = ResourceConstRef<TextRaw, TextRawConst>;
 
#ifdef SDL3PP_DOC

#define SDL_TTF_MAJOR_VERSION
 
#define SDL_TTF_MINOR_VERSION
 
#define SDL_TTF_MICRO_VERSION


#define SDL_TTF_VERSION                                                        \
  SDL_VERSIONNUM(                                                              \
    SDL_TTF_MAJOR_VERSION, SDL_TTF_MINOR_VERSION, SDL_TTF_MICRO_VERSION)

#define SDL_TTF_VERSION_ATLEAST(X, Y, Z)                                       \
  ((SDL_TTF_MAJOR_VERSION >= X) &&                                             \
   (SDL_TTF_MAJOR_VERSION > X || SDL_TTF_MINOR_VERSION >= Y) &&                \
   (SDL_TTF_MAJOR_VERSION > X || SDL_TTF_MINOR_VERSION > Y ||                  \
    SDL_TTF_MICRO_VERSION >= Z))
 
#endif // SDL3PP_DOC
 
namespace TTF {

inline int Version() { return TTF_Version(); }

inline void Init() { CheckError(TTF_Init()); }

inline void Quit() { TTF_Quit(); }

inline int WasInit() { return TTF_WasInit(); }
 
} // namespace TTF

inline void GetFreeTypeVersion(int* major, int* minor, int* patch)
{
  TTF_GetFreeTypeVersion(major, minor, patch);
}

inline void GetHarfBuzzVersion(int* major, int* minor, int* patch)
{
  TTF_GetHarfBuzzVersion(major, minor, patch);
}

using FontStyleFlags = Uint32;
 
constexpr FontStyleFlags STYLE_NORMAL = TTF_STYLE_NORMAL; 
 
constexpr FontStyleFlags STYLE_BOLD = TTF_STYLE_BOLD; 
 
constexpr FontStyleFlags STYLE_ITALIC = TTF_STYLE_ITALIC; 
 
constexpr FontStyleFlags STYLE_UNDERLINE =
  TTF_STYLE_UNDERLINE; 
 
constexpr FontStyleFlags STYLE_STRIKETHROUGH =
  TTF_STYLE_STRIKETHROUGH; 

using HintingFlags = TTF_HintingFlags;
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
constexpr HintingFlags HINTING_INVALID = TTF_HINTING_INVALID; 
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
constexpr HintingFlags HINTING_NORMAL =
  TTF_HINTING_NORMAL; 

constexpr HintingFlags HINTING_LIGHT = TTF_HINTING_LIGHT;

constexpr HintingFlags HINTING_MONO = TTF_HINTING_MONO;

constexpr HintingFlags HINTING_NONE = TTF_HINTING_NONE;

constexpr HintingFlags HINTING_LIGHT_SUBPIXEL = TTF_HINTING_LIGHT_SUBPIXEL;

using HorizontalAlignment = TTF_HorizontalAlignment;
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_INVALID =
  TTF_HORIZONTAL_ALIGN_INVALID; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_LEFT =
  TTF_HORIZONTAL_ALIGN_LEFT; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_CENTER =
  TTF_HORIZONTAL_ALIGN_CENTER; 
 
constexpr HorizontalAlignment HORIZONTAL_ALIGN_RIGHT =
  TTF_HORIZONTAL_ALIGN_RIGHT; 

using Direction = TTF_Direction;
 
constexpr Direction DIRECTION_INVALID = TTF_DIRECTION_INVALID; 
 
constexpr Direction DIRECTION_LTR = TTF_DIRECTION_LTR; 
 
constexpr Direction DIRECTION_RTL = TTF_DIRECTION_RTL; 
 
constexpr Direction DIRECTION_TTB = TTF_DIRECTION_TTB; 
 
constexpr Direction DIRECTION_BTT = TTF_DIRECTION_BTT; 

using ImageType = TTF_ImageType;
 
constexpr ImageType IMAGE_INVALID = TTF_IMAGE_INVALID; 
 
constexpr ImageType IMAGE_ALPHA =
  TTF_IMAGE_ALPHA; 
 
constexpr ImageType IMAGE_COLOR =
  TTF_IMAGE_COLOR; 

constexpr ImageType IMAGE_SDF = TTF_IMAGE_SDF;

struct FontBase : ResourceBaseT<FontRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Close();

  Font Copy() const;

  PropertiesRef GetProperties();

  Uint32 GetGeneration() const;

  void AddFallback(FontRef fallback);

  void RemoveFallback(FontRef fallback);

  void ClearFallbacks();

  void SetSize(float ptsize);

  void SetSizeDPI(float ptsize, int hdpi, int vdpi);

  float GetSize() const;

  void GetDPI(int* hdpi, int* vdpi) const;

  void SetStyle(FontStyleFlags style);

  FontStyleFlags GetStyle() const;

  void SetOutline(int outline);

  int GetOutline() const;

  void SetHinting(HintingFlags hinting);

  int GetNumFaces() const;

  HintingFlags GetHinting() const;

  void SetSDF(bool enabled);

  bool GetSDF() const;
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)

  int GetWeight() const;
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)

  void SetWrapAlignment(HorizontalAlignment align);

  HorizontalAlignment GetWrapAlignment() const;

  int GetHeight() const;

  int GetAscent() const;

  int GetDescent() const;

  void SetLineSkip(int lineskip);

  int GetLineSkip() const;

  void SetKerning(bool enabled);

  bool GetKerning() const;

  bool IsFixedWidth() const;

  bool IsScalable() const;

  const char* GetFamilyName() const;

  const char* GetStyleName() const;

  void SetDirection(Direction direction);

  Direction GetDirection() const;

  void SetScript(Uint32 script);

  Uint32 GetScript() const;

  static Uint32 GetGlyphScript(Uint32 ch);

  void SetLanguage(StringParam language_bcp47);

  bool HasGlyph(Uint32 ch) const;

  Surface GetGlyphImage(Uint32 ch, ImageType* image_type) const;

  Surface GetGlyphImageForIndex(Uint32 glyph_index,
                                ImageType* image_type) const;

  void GetGlyphMetrics(Uint32 ch,
                       int* minx,
                       int* maxx,
                       int* miny,
                       int* maxy,
                       int* advance) const;

  int GetGlyphKerning(Uint32 previous_ch, Uint32 ch) const;

  Point GetStringSize(std::string_view text) const
  {
    Point p;
    GetStringSize(text, &p.x, &p.y);
    return p;
  }

  void GetStringSize(std::string_view text, int* w, int* h) const;

  Point GetStringSizeWrapped(std::string_view text, int wrap_width) const
  {
    Point p;
    GetStringSizeWrapped(text, wrap_width, &p.x, &p.y);
    return p;
  }

  void GetStringSizeWrapped(std::string_view text,
                            int wrap_width,
                            int* w,
                            int* h) const;

  void MeasureString(std::string_view text,
                     int max_width,
                     int* measured_width,
                     size_t* measured_length) const;

  Surface RenderText_Solid(std::string_view text, Color fg) const;

  Surface RenderText_Solid_Wrapped(std::string_view text,
                                   Color fg,
                                   int wrapLength) const;

  Surface RenderGlyph_Solid(Uint32 ch, ColorRaw fg) const;

  Surface RenderText_Shaded(std::string_view text, Color fg, Color bg) const;

  Surface RenderText_Shaded_Wrapped(std::string_view text,
                                    Color fg,
                                    Color bg,
                                    int wrap_width) const;

  Surface RenderGlyph_Shaded(Uint32 ch, ColorRaw fg, ColorRaw bg) const;

  Surface RenderText_Blended(std::string_view text, Color fg) const;

  Surface RenderText_Blended_Wrapped(std::string_view text,
                                     Color fg,
                                     int wrap_width) const;

  Surface RenderGlyph_Blended(Uint32 ch, ColorRaw fg) const;

  Surface RenderText_LCD(std::string_view text, Color fg, Color bg) const;

  Surface RenderText_LCD_Wrapped(std::string_view text,
                                 Color fg,
                                 Color bg,
                                 int wrap_width) const;

  Surface RenderGlyph_LCD(Uint32 ch, ColorRaw fg, ColorRaw bg) const;
};

struct Font : FontBase
{
  using FontBase::FontBase;

  constexpr explicit Font(FontRaw resource) noexcept
    : FontBase(resource)
  {
  }

  constexpr Font(Font&& other) noexcept
    : Font(other.release())
  {
  }

  Font(StringParam file, float ptsize);

  Font(IOStreamRef src, float ptsize, bool closeio = false);

  Font(PropertiesRef props);

  ~Font() { TTF_CloseFont(get()); }

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

inline Font OpenFont(StringParam file, float ptsize)
{
  return Font(file, ptsize);
}
 
inline Font::Font(StringParam file, float ptsize)
  : Font(CheckError(TTF_OpenFont(file, ptsize)))
{
}
 
inline Font::Font(IOStreamRef src, float ptsize, bool closeio)
  : Font(CheckError(TTF_OpenFontIO(src, closeio, ptsize)))
{
}
 
inline Font::Font(PropertiesRef props)
  : Font(CheckError(TTF_OpenFontWithProperties(props)))
{
}

inline Font OpenFontIO(IOStreamRef src, float ptsize, bool closeio = false)
{
  return Font(src, ptsize, closeio);
}

inline Font OpenFontWithProperties(PropertiesRef props) { return Font(props); }

namespace prop::Font::Create {
 
constexpr auto FILENAME_STRING =
  TTF_PROP_FONT_CREATE_FILENAME_STRING; 
 
constexpr auto IOSTREAM_POINTER =
  TTF_PROP_FONT_CREATE_IOSTREAM_POINTER; 
 
constexpr auto IOSTREAM_OFFSET_NUMBER =
  TTF_PROP_FONT_CREATE_IOSTREAM_OFFSET_NUMBER; 
 
constexpr auto IOSTREAM_AUTOCLOSE_BOOLEAN =
  TTF_PROP_FONT_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN; 
 
constexpr auto SIZE_FLOAT =
  TTF_PROP_FONT_CREATE_SIZE_FLOAT; 
 
constexpr auto FACE_NUMBER =
  TTF_PROP_FONT_CREATE_FACE_NUMBER; 
 
constexpr auto HORIZONTAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_HORIZONTAL_DPI_NUMBER; 
 
constexpr auto VERTICAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_VERTICAL_DPI_NUMBER; 
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
constexpr auto EXISTING_FONT_POINTER =
  TTF_PROP_FONT_CREATE_EXISTING_FONT; 
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
} // namespace prop::Font::Create

inline Font CopyFont(FontRef existing_font)
{
  return Font(CheckError(TTF_CopyFont(existing_font)));
}
 
inline Font FontBase::Copy() const { return SDL::CopyFont(get()); }

inline PropertiesRef GetFontProperties(FontRef font)
{
  return CheckError(TTF_GetFontProperties(font));
}
 
inline PropertiesRef FontBase::GetProperties()
{
  return SDL::GetFontProperties(get());
}

namespace prop::Font {
 
constexpr auto OUTLINE_LINE_CAP_NUMBER =
  TTF_PROP_FONT_OUTLINE_LINE_CAP_NUMBER; 
 
constexpr auto OUTLINE_LINE_JOIN_NUMBER =
  TTF_PROP_FONT_OUTLINE_LINE_JOIN_NUMBER; 
 
constexpr auto OUTLINE_MITER_LIMIT_NUMBER =
  TTF_PROP_FONT_OUTLINE_MITER_LIMIT_NUMBER; 
 
} // namespace prop::Font

inline Uint32 GetFontGeneration(FontRef font)
{
  return TTF_GetFontGeneration(font);
}
 
inline Uint32 FontBase::GetGeneration() const
{
  return SDL::GetFontGeneration(get());
}

inline void AddFallbackFont(FontRef font, FontRef fallback)
{
  CheckError(TTF_AddFallbackFont(font, fallback));
}
 
inline void FontBase::AddFallback(FontRef fallback)
{
  SDL::AddFallbackFont(get(), fallback);
}

inline void RemoveFallbackFont(FontRef font, FontRef fallback)
{
  TTF_RemoveFallbackFont(font, fallback);
}
 
inline void FontBase::RemoveFallback(FontRef fallback)
{
  SDL::RemoveFallbackFont(get(), fallback);
}

inline void ClearFallbackFonts(FontRef font) { TTF_ClearFallbackFonts(font); }
 
inline void FontBase::ClearFallbacks() { SDL::ClearFallbackFonts(get()); }

inline void SetFontSize(FontRef font, float ptsize)
{
  CheckError(TTF_SetFontSize(font, ptsize));
}
 
inline void FontBase::SetSize(float ptsize) { SDL::SetFontSize(get(), ptsize); }

inline void SetFontSizeDPI(FontRef font, float ptsize, int hdpi, int vdpi)
{
  CheckError(TTF_SetFontSizeDPI(font, ptsize, hdpi, vdpi));
}
 
inline void FontBase::SetSizeDPI(float ptsize, int hdpi, int vdpi)
{
  SDL::SetFontSizeDPI(get(), ptsize, hdpi, vdpi);
}

inline float GetFontSize(FontRef font) { return TTF_GetFontSize(font); }
 
inline float FontBase::GetSize() const { return SDL::GetFontSize(get()); }

inline void GetFontDPI(FontRef font, int* hdpi, int* vdpi)
{
  CheckError(TTF_GetFontDPI(font, hdpi, vdpi));
}
 
inline void FontBase::GetDPI(int* hdpi, int* vdpi) const
{
  SDL::GetFontDPI(get(), hdpi, vdpi);
}

inline void SetFontStyle(FontRef font, FontStyleFlags style)
{
  TTF_SetFontStyle(font, style);
}
 
inline void FontBase::SetStyle(FontStyleFlags style)
{
  SDL::SetFontStyle(get(), style);
}

inline FontStyleFlags GetFontStyle(FontRef font)
{
  return TTF_GetFontStyle(font);
}
 
inline FontStyleFlags FontBase::GetStyle() const
{
  return SDL::GetFontStyle(get());
}

inline void SetFontOutline(FontRef font, int outline)
{
  CheckError(TTF_SetFontOutline(font, outline));
}
 
inline void FontBase::SetOutline(int outline)
{
  SDL::SetFontOutline(get(), outline);
}

inline int GetFontOutline(FontRef font) { return TTF_GetFontOutline(font); }
 
inline int FontBase::GetOutline() const { return SDL::GetFontOutline(get()); }

inline void SetFontHinting(FontRef font, HintingFlags hinting)
{
  TTF_SetFontHinting(font, hinting);
}
 
inline void FontBase::SetHinting(HintingFlags hinting)
{
  SDL::SetFontHinting(get(), hinting);
}

inline int GetNumFontFaces(FontRef font) { return TTF_GetNumFontFaces(font); }
 
inline int FontBase::GetNumFaces() const { return SDL::GetNumFontFaces(get()); }

inline HintingFlags GetFontHinting(FontRef font)
{
  return TTF_GetFontHinting(font);
}
 
inline HintingFlags FontBase::GetHinting() const
{
  return SDL::GetFontHinting(get());
}

inline void SetFontSDF(FontRef font, bool enabled)
{
  CheckError(TTF_SetFontSDF(font, enabled));
}
 
inline void FontBase::SetSDF(bool enabled) { SDL::SetFontSDF(get(), enabled); }

inline bool GetFontSDF(FontRef font) { return TTF_GetFontSDF(font); }
 
inline bool FontBase::GetSDF() const { return SDL::GetFontSDF(get()); }
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)

inline int GetFontWeight(FontRef font) { return TTF_GetFontWeight(font); }
 
inline int FontBase::GetWeight() const { return SDL::GetFontWeight(get()); }
 
constexpr int FONT_WEIGHT_THIN =
  TTF_FONT_WEIGHT_THIN; 
 
constexpr int FONT_WEIGHT_EXTRA_LIGHT =
  TTF_FONT_WEIGHT_EXTRA_LIGHT; 
 
constexpr int FONT_WEIGHT_LIGHT =
  TTF_FONT_WEIGHT_LIGHT; 
 
constexpr int FONT_WEIGHT_NORMAL =
  TTF_FONT_WEIGHT_NORMAL; 
 
constexpr int FONT_WEIGHT_MEDIUM =
  TTF_FONT_WEIGHT_MEDIUM; 
 
constexpr int FONT_WEIGHT_SEMI_BOLD =
  TTF_FONT_WEIGHT_SEMI_BOLD; 
 
constexpr int FONT_WEIGHT_BOLD =
  TTF_FONT_WEIGHT_BOLD; 
 
constexpr int FONT_WEIGHT_EXTRA_BOLD =
  TTF_FONT_WEIGHT_EXTRA_BOLD; 
 
constexpr int FONT_WEIGHT_BLACK =
  TTF_FONT_WEIGHT_BLACK; 
 
constexpr int FONT_WEIGHT_EXTRA_BLACK =
  TTF_FONT_WEIGHT_EXTRA_BLACK; 
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)

inline void SetFontWrapAlignment(FontRef font, HorizontalAlignment align)
{
  TTF_SetFontWrapAlignment(font, align);
}
 
inline void FontBase::SetWrapAlignment(HorizontalAlignment align)
{
  SDL::SetFontWrapAlignment(get(), align);
}

inline HorizontalAlignment GetFontWrapAlignment(FontRef font)
{
  return TTF_GetFontWrapAlignment(font);
}
 
inline HorizontalAlignment FontBase::GetWrapAlignment() const
{
  return SDL::GetFontWrapAlignment(get());
}

inline int GetFontHeight(FontRef font) { return TTF_GetFontHeight(font); }
 
inline int FontBase::GetHeight() const { return SDL::GetFontHeight(get()); }

inline int GetFontAscent(FontRef font) { return TTF_GetFontAscent(font); }
 
inline int FontBase::GetAscent() const { return SDL::GetFontAscent(get()); }

inline int GetFontDescent(FontRef font) { return TTF_GetFontDescent(font); }
 
inline int FontBase::GetDescent() const { return SDL::GetFontDescent(get()); }

inline void SetFontLineSkip(FontRef font, int lineskip)
{
  TTF_SetFontLineSkip(font, lineskip);
}
 
inline void FontBase::SetLineSkip(int lineskip)
{
  SDL::SetFontLineSkip(get(), lineskip);
}

inline int GetFontLineSkip(FontRef font) { return TTF_GetFontLineSkip(font); }
 
inline int FontBase::GetLineSkip() const { return SDL::GetFontLineSkip(get()); }

inline void SetFontKerning(FontRef font, bool enabled)
{
  TTF_SetFontKerning(font, enabled);
}
 
inline void FontBase::SetKerning(bool enabled)
{
  SDL::SetFontKerning(get(), enabled);
}

inline bool GetFontKerning(FontRef font) { return TTF_GetFontKerning(font); }
 
inline bool FontBase::GetKerning() const { return SDL::GetFontKerning(get()); }

inline bool FontIsFixedWidth(FontRef font)
{
  return TTF_FontIsFixedWidth(font);
}
 
inline bool FontBase::IsFixedWidth() const
{
  return SDL::FontIsFixedWidth(get());
}

inline bool FontIsScalable(FontRef font) { return TTF_FontIsScalable(font); }
 
inline bool FontBase::IsScalable() const { return SDL::FontIsScalable(get()); }

inline const char* GetFontFamilyName(FontRef font)
{
  return TTF_GetFontFamilyName(font);
}
 
inline const char* FontBase::GetFamilyName() const
{
  return SDL::GetFontFamilyName(get());
}

inline const char* GetFontStyleName(FontRef font)
{
  return TTF_GetFontStyleName(font);
}
 
inline const char* FontBase::GetStyleName() const
{
  return SDL::GetFontStyleName(get());
}

inline void SetFontDirection(FontRef font, Direction direction)
{
  CheckError(TTF_SetFontDirection(font, direction));
}
 
inline void FontBase::SetDirection(Direction direction)
{
  SDL::SetFontDirection(get(), direction);
}

inline Direction GetFontDirection(FontRef font)
{
  return TTF_GetFontDirection(font);
}
 
inline Direction FontBase::GetDirection() const
{
  return SDL::GetFontDirection(get());
}

inline Uint32 StringToTag(StringParam string)
{
  return TTF_StringToTag(string);
}

inline void TagToString(Uint32 tag, char* string, size_t size)
{
  TTF_TagToString(tag, string, size);
}

inline void SetFontScript(FontRef font, Uint32 script)
{
  CheckError(TTF_SetFontScript(font, script));
}
 
inline void FontBase::SetScript(Uint32 script)
{
  SDL::SetFontScript(get(), script);
}

inline Uint32 GetFontScript(FontRef font) { return TTF_GetFontScript(font); }
 
inline Uint32 FontBase::GetScript() const { return SDL::GetFontScript(get()); }

inline Uint32 GetGlyphScript(Uint32 ch)
{
  return CheckError(TTF_GetGlyphScript(ch));
}
 
inline Uint32 FontBase::GetGlyphScript(Uint32 ch)
{
  return SDL::GetGlyphScript(ch);
}

inline void SetFontLanguage(FontRef font, StringParam language_bcp47)
{
  CheckError(TTF_SetFontLanguage(font, language_bcp47));
}
 
inline void FontBase::SetLanguage(StringParam language_bcp47)
{
  SDL::SetFontLanguage(get(), language_bcp47);
}

inline bool FontHasGlyph(FontRef font, Uint32 ch)
{
  return TTF_FontHasGlyph(font, ch);
}
 
inline bool FontBase::HasGlyph(Uint32 ch) const
{
  return SDL::FontHasGlyph(get(), ch);
}

inline Surface GetGlyphImage(FontRef font, Uint32 ch, ImageType* image_type)
{
  return Surface{CheckError(TTF_GetGlyphImage(font, ch, image_type))};
}
 
inline Surface FontBase::GetGlyphImage(Uint32 ch, ImageType* image_type) const
{
  return SDL::GetGlyphImage(get(), ch, image_type);
}

inline Surface GetGlyphImageForIndex(FontRef font,
                                     Uint32 glyph_index,
                                     ImageType* image_type)
{
  return Surface(
    CheckError(TTF_GetGlyphImageForIndex(font, glyph_index, image_type)));
}
 
inline Surface FontBase::GetGlyphImageForIndex(Uint32 glyph_index,
                                               ImageType* image_type) const
{
  return SDL::GetGlyphImageForIndex(get(), glyph_index, image_type);
}

inline void GetGlyphMetrics(FontRef font,
                            Uint32 ch,
                            int* minx,
                            int* maxx,
                            int* miny,
                            int* maxy,
                            int* advance)
{
  CheckError(TTF_GetGlyphMetrics(font, ch, minx, maxx, miny, maxy, advance));
}
 
inline void FontBase::GetGlyphMetrics(Uint32 ch,
                                      int* minx,
                                      int* maxx,
                                      int* miny,
                                      int* maxy,
                                      int* advance) const
{
  SDL::GetGlyphMetrics(get(), ch, minx, maxx, miny, maxy, advance);
}

inline int GetGlyphKerning(FontRef font, Uint32 previous_ch, Uint32 ch)
{
  if (int r; TTF_GetGlyphKerning(font, previous_ch, ch, &r)) return r;
  throw Error();
}
 
inline int FontBase::GetGlyphKerning(Uint32 previous_ch, Uint32 ch) const
{
  return SDL::GetGlyphKerning(get(), previous_ch, ch);
}

inline void GetStringSize(FontRef font, std::string_view text, int* w, int* h)
{
  CheckError(TTF_GetStringSize(font, text.data(), text.size(), w, h));
}
 
inline void FontBase::GetStringSize(std::string_view text, int* w, int* h) const
{
  SDL::GetStringSize(get(), text, w, h);
}

inline void GetStringSizeWrapped(FontRef font,
                                 std::string_view text,
                                 int wrap_width,
                                 int* w,
                                 int* h)
{
  CheckError(
    TTF_GetStringSizeWrapped(font, text.data(), text.size(), wrap_width, w, h));
}
 
inline void FontBase::GetStringSizeWrapped(std::string_view text,
                                           int wrap_width,
                                           int* w,
                                           int* h) const
{
  SDL::GetStringSizeWrapped(get(), text, wrap_width, w, h);
}

inline void MeasureString(FontRef font,
                          std::string_view text,
                          int max_width,
                          int* measured_width,
                          size_t* measured_length)
{
  CheckError(TTF_MeasureString(font,
                               text.data(),
                               text.size(),
                               max_width,
                               measured_width,
                               measured_length));
}
 
inline void FontBase::MeasureString(std::string_view text,
                                    int max_width,
                                    int* measured_width,
                                    size_t* measured_length) const
{
  SDL::MeasureString(get(), text, max_width, measured_width, measured_length);
}

inline Surface RenderText_Solid(FontRef font, std::string_view text, Color fg)
{
  return Surface{TTF_RenderText_Solid(font, text.data(), text.size(), fg)};
}
 
inline Surface FontBase::RenderText_Solid(std::string_view text, Color fg) const
{
  return SDL::RenderText_Solid(get(), text, fg);
}

inline Surface RenderText_Solid_Wrapped(FontRef font,
                                        std::string_view text,
                                        Color fg,
                                        int wrapLength)
{
  return Surface(TTF_RenderText_Solid_Wrapped(
    font, text.data(), text.size(), fg, wrapLength));
}
 
inline Surface FontBase::RenderText_Solid_Wrapped(std::string_view text,
                                                  Color fg,
                                                  int wrapLength) const
{
  return SDL::RenderText_Solid_Wrapped(get(), text, fg, wrapLength);
}

inline Surface RenderGlyph_Solid(FontRef font, Uint32 ch, ColorRaw fg)
{
  return Surface(TTF_RenderGlyph_Solid(font, ch, fg));
}
 
inline Surface FontBase::RenderGlyph_Solid(Uint32 ch, ColorRaw fg) const
{
  return SDL::RenderGlyph_Solid(get(), ch, fg);
}

inline Surface RenderText_Shaded(FontRef font,
                                 std::string_view text,
                                 Color fg,
                                 Color bg)
{
  return Surface(TTF_RenderText_Shaded(font, text.data(), text.size(), fg, bg));
}
 
inline Surface FontBase::RenderText_Shaded(std::string_view text,
                                           Color fg,
                                           Color bg) const
{
  return SDL::RenderText_Shaded(get(), text, fg, bg);
}

inline Surface RenderText_Shaded_Wrapped(FontRef font,
                                         std::string_view text,
                                         Color fg,
                                         Color bg,
                                         int wrap_width)
{
  return Surface(TTF_RenderText_Shaded_Wrapped(
    font, text.data(), text.size(), fg, bg, wrap_width));
}
 
inline Surface FontBase::RenderText_Shaded_Wrapped(std::string_view text,
                                                   Color fg,
                                                   Color bg,
                                                   int wrap_width) const
{
  return SDL::RenderText_Shaded_Wrapped(get(), text, fg, bg, wrap_width);
}

inline Surface RenderGlyph_Shaded(FontRef font,
                                  Uint32 ch,
                                  ColorRaw fg,
                                  ColorRaw bg)
{
  return Surface(TTF_RenderGlyph_Shaded(font, ch, fg, bg));
}
 
inline Surface FontBase::RenderGlyph_Shaded(Uint32 ch,
                                            ColorRaw fg,
                                            ColorRaw bg) const
{
  return SDL::RenderGlyph_Shaded(get(), ch, fg, bg);
}

inline Surface RenderText_Blended(FontRef font, std::string_view text, Color fg)
{
  return Surface(TTF_RenderText_Blended(font, text.data(), text.size(), fg));
}
 
inline Surface FontBase::RenderText_Blended(std::string_view text,
                                            Color fg) const
{
  return SDL::RenderText_Blended(get(), text, fg);
}

inline Surface RenderText_Blended_Wrapped(FontRef font,
                                          std::string_view text,
                                          Color fg,
                                          int wrap_width)
{
  return Surface(TTF_RenderText_Blended_Wrapped(
    font, text.data(), text.size(), fg, wrap_width));
}
 
inline Surface FontBase::RenderText_Blended_Wrapped(std::string_view text,
                                                    Color fg,
                                                    int wrap_width) const
{
  return SDL::RenderText_Blended_Wrapped(get(), text, fg, wrap_width);
}

inline Surface RenderGlyph_Blended(FontRef font, Uint32 ch, ColorRaw fg)
{
  return Surface(TTF_RenderGlyph_Blended(font, ch, fg));
}
 
inline Surface FontBase::RenderGlyph_Blended(Uint32 ch, ColorRaw fg) const
{
  return SDL::RenderGlyph_Blended(get(), ch, fg);
}

inline Surface RenderText_LCD(FontRef font,
                              std::string_view text,
                              Color fg,
                              Color bg)
{
  return Surface(TTF_RenderText_LCD(font, text.data(), text.size(), fg, bg));
}
 
inline Surface FontBase::RenderText_LCD(std::string_view text,
                                        Color fg,
                                        Color bg) const
{
  return SDL::RenderText_LCD(get(), text, fg, bg);
}

inline Surface RenderText_LCD_Wrapped(FontRef font,
                                      std::string_view text,
                                      Color fg,
                                      Color bg,
                                      int wrap_width)
{
  return Surface(TTF_RenderText_LCD_Wrapped(
    font, text.data(), text.size(), fg, bg, wrap_width));
}
 
inline Surface FontBase::RenderText_LCD_Wrapped(std::string_view text,
                                                Color fg,
                                                Color bg,
                                                int wrap_width) const
{
  return SDL::RenderText_LCD_Wrapped(get(), text, fg, bg, wrap_width);
}

inline Surface RenderGlyph_LCD(FontRef font,
                               Uint32 ch,
                               ColorRaw fg,
                               ColorRaw bg)
{
  return Surface(TTF_RenderGlyph_LCD(font, ch, fg, bg));
}
 
inline Surface FontBase::RenderGlyph_LCD(Uint32 ch,
                                         ColorRaw fg,
                                         ColorRaw bg) const
{
  return SDL::RenderGlyph_LCD(get(), ch, fg, bg);
}

using SubStringFlags = Uint32;
 
constexpr SubStringFlags SUBSTRING_DIRECTION_MASK =
  TTF_SUBSTRING_DIRECTION_MASK; 
 
constexpr SubStringFlags SUBSTRING_TEXT_START =
  TTF_SUBSTRING_TEXT_START; 

constexpr SubStringFlags SUBSTRING_LINE_START = TTF_SUBSTRING_LINE_START;

constexpr SubStringFlags SUBSTRING_LINE_END = TTF_SUBSTRING_LINE_END;
 
constexpr SubStringFlags SUBSTRING_TEXT_END =
  TTF_SUBSTRING_TEXT_END; 

using GPUTextEngineWinding = TTF_GPUTextEngineWinding;
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_INVALID =
  TTF_GPU_TEXTENGINE_WINDING_INVALID; 
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_CLOCKWISE =
  TTF_GPU_TEXTENGINE_WINDING_CLOCKWISE; 
 
constexpr GPUTextEngineWinding GPU_TEXTENGINE_WINDING_COUNTER_CLOCKWISE =
  TTF_GPU_TEXTENGINE_WINDING_COUNTER_CLOCKWISE; 

struct TextEngine : ResourceBaseT<TextEngineRaw>
{
  using ResourceBaseT::ResourceBaseT;

  Text CreateText(FontRef font, std::string_view text);
};

struct SurfaceTextEngine : TextEngine
{
  using TextEngine::TextEngine;

  constexpr explicit SurfaceTextEngine(TextEngineRaw resource) noexcept
    : TextEngine(resource)
  {
  }

  constexpr SurfaceTextEngine(SurfaceTextEngine&& other) noexcept
    : TextEngine(other.release())
  {
  }

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

  SurfaceTextEngine();

  ~SurfaceTextEngine() { Destroy(); }

  void Destroy();
};

struct RendererTextEngine : TextEngine
{
  using TextEngine::TextEngine;

  constexpr explicit RendererTextEngine(TextEngineRaw resource) noexcept
    : TextEngine(resource)
  {
  }

  constexpr RendererTextEngine(RendererTextEngine&& other) noexcept
    : TextEngine(other.release())
  {
  }

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

  RendererTextEngine(RendererRef renderer);

  RendererTextEngine(PropertiesRef props);

  ~RendererTextEngine() { Destroy(); }

  void Destroy();
};

struct GPUTextEngine : TextEngine
{
  using TextEngine::TextEngine;

  constexpr explicit GPUTextEngine(TextEngineRaw resource) noexcept
    : TextEngine(resource)
  {
  }

  constexpr GPUTextEngine(GPUTextEngine&& other) noexcept
    : TextEngine(other.release())
  {
  }

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

  GPUTextEngine(GPUDeviceRef device);

  GPUTextEngine(PropertiesRef props);

  ~GPUTextEngine() { Destroy(); }

  void SetGPUWinding(GPUTextEngineWinding winding);

  GPUTextEngineWinding GetGPUWinding() const;

  void Destroy();
};

using GPUAtlasDrawSequence = TTF_GPUAtlasDrawSequence;

using SubString = TTF_SubString;
 
// Forward decl
struct SubStringIterator;

using TextData = TTF_TextData;

struct TextBase : ResourceBaseT<TextRaw, TextRawConst>
{
  using ResourceBaseT::ResourceBaseT;

  constexpr operator TextConstRef() const noexcept { return get(); }

  void Destroy();

  void DrawSurface(Point p, SurfaceRef surface) const;

  void DrawRenderer(FPoint p) const;

  GPUAtlasDrawSequence* GetGPUDrawData() const;

  PropertiesRef GetProperties() const;

  void SetEngine(TextEngineRef engine);

  TextEngineRef GetEngine() const;

  bool SetFont(FontRef font);

  FontRef GetFont() const;

  void SetDirection(Direction direction);

  Direction GetDirection() const;

  void SetScript(Uint32 script);

  Uint32 GetScript() const;

  void SetColor(Color c);

  void SetColorFloat(FColor c);

  void GetColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const;

  Color GetColor() const;

  void GetColorFloat(float* r, float* g, float* b, float* a) const;

  FColor GetColorFloat() const;

  void SetPosition(const PointRaw& p);

  void GetPosition(int* x, int* y) const;

  Point GetPosition() const;

  void SetWrapWidth(int wrap_width);

  int GetWrapWidth() const;

  void SetWrapWhitespaceVisible(bool visible);

  bool IsWrapWhitespaceVisible() const;

  void SetString(std::string_view string);

  void InsertString(int offset, std::string_view string);

  void AppendString(std::string_view string);

  void DeleteString(int offset, int length);

  void GetSize(int* w, int* h) const;

  Point GetSize() const;

  void GetSubString(int offset, SubString* substring) const;

  SubStringIterator begin() const;

  SubStringIterator end() const;

  SubStringIterator GetSubStringForLine(int line) const;

  void GetSubStringForLine(int line, SubString* substring) const;

  OwnArray<SubString*> GetSubStrings() const
  {
    return GetSubStringsForRange(0);
  }

  OwnArray<SubString*> GetSubStringsForRange(int offset, int length = -1) const;

  SubStringIterator GetSubStringForPoint(Point p) const;

  void GetSubStringForPoint(Point p, SubString* substring) const;

  void GetPreviousSubString(const SubString& substring,
                            SubString* previous) const;

  void GetNextSubString(const SubString& substring, SubString* next) const;

  void Update();

  const char* GetText() const { return get()->text; }

  int GetNumLines() const { return get()->num_lines; }
};

struct Text : TextBase
{
  using TextBase::TextBase;

  constexpr explicit Text(TextRaw resource) noexcept
    : TextBase(resource)
  {
  }

  constexpr Text(Text&& other) noexcept
    : Text(other.release())
  {
  }

  Text(TextEngineRef engine, FontRef font, std::string_view text);

  ~Text() { TTF_DestroyText(get()); }

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

class SubStringIterator
{
  TextRef m_text;
 
  SubString m_subString;
 
  SubStringIterator(TextRef text)
    : m_text(text)
    , m_subString()
  {
  }
 
public:
  SubStringIterator()
    : SubStringIterator(TextRef{})
  {
  }

  constexpr operator bool() const { return bool(m_text); }

  constexpr const SubString& operator*() const { return m_subString; }

  constexpr const SubString* operator->() const { return &m_subString; }

  constexpr bool operator==(const SubStringIterator& other) const
  {
    return m_subString.offset == other.m_subString.offset;
  }

  SubStringIterator& operator++()
  {
    m_text.GetNextSubString(m_subString, &m_subString);
    return *this;
  }

  SubStringIterator operator++(int)
  {
    auto curr = *this;
    m_text.GetNextSubString(m_subString, &m_subString);
    return curr;
  }

  SubStringIterator& operator--()
  {
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return *this;
  }

  SubStringIterator operator--(int)
  {
    auto curr = *this;
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return curr;
  }
 
  friend class Text;
};

inline SurfaceTextEngine CreateSurfaceTextEngine()
{
  return SurfaceTextEngine();
}
 
inline SurfaceTextEngine::SurfaceTextEngine()
  : TextEngine(TTF_CreateSurfaceTextEngine())
{
}

inline void DrawSurfaceText(TextConstRef text, Point p, SurfaceRef surface)
{
  CheckError(TTF_DrawSurfaceText(text, p.x, p.y, surface));
}
 
inline void TextBase::DrawSurface(Point p, SurfaceRef surface) const
{
  SDL::DrawSurfaceText(get(), p, surface);
}

inline void DestroySurfaceTextEngine(TextEngineRaw engine)
{
  TTF_DestroySurfaceTextEngine(engine);
}
 
inline void SurfaceTextEngine::Destroy()
{
  DestroySurfaceTextEngine(release());
}

inline RendererTextEngine CreateRendererTextEngine(RendererRef renderer)
{
  return RendererTextEngine(renderer);
}
 
inline RendererTextEngine::RendererTextEngine(RendererRef renderer)
  : TextEngine(TTF_CreateRendererTextEngine(renderer))
{
}
 
inline RendererTextEngine::RendererTextEngine(PropertiesRef props)
  : TextEngine(TTF_CreateRendererTextEngineWithProperties(props))
{
}

inline RendererTextEngine CreateRendererTextEngineWithProperties(
  PropertiesRef props)
{
  return RendererTextEngine(props);
}

namespace prop::RendererTextEngine {
 
constexpr auto RENDERER_POINTER =
  TTF_PROP_RENDERER_TEXT_ENGINE_RENDERER; 
 
constexpr auto ATLAS_TEXTURE_SIZE_NUMBER =
  TTF_PROP_RENDERER_TEXT_ENGINE_ATLAS_TEXTURE_SIZE; 
 
} // namespace prop::RendererTextEngine

inline void DrawRendererText(TextConstRef text, FPoint p)
{
  CheckError(TTF_DrawRendererText(text, p.x, p.y));
}
 
inline void TextBase::DrawRenderer(FPoint p) const
{
  SDL::DrawRendererText(get(), p);
}

inline void DestroyRendererTextEngine(TextEngineRaw engine)
{
  TTF_DestroyRendererTextEngine(engine);
}
 
inline void RendererTextEngine::Destroy()
{
  DestroyRendererTextEngine(release());
}

inline GPUTextEngine CreateGPUTextEngine(GPUDeviceRef device)
{
  return GPUTextEngine(device);
}
 
inline GPUTextEngine::GPUTextEngine(GPUDeviceRef device)
  : TextEngine(TTF_CreateGPUTextEngine(device))
{
}
 
inline GPUTextEngine::GPUTextEngine(PropertiesRef props)
  : TextEngine(TTF_CreateGPUTextEngineWithProperties(props))
{
}

inline GPUTextEngine CreateGPUTextEngineWithProperties(PropertiesRef props)
{
  return GPUTextEngine(props);
}

namespace prop::GpuTextEngine {
 
constexpr auto DEVICE_POINTER =
  TTF_PROP_GPU_TEXT_ENGINE_DEVICE; 
 
constexpr auto ATLAS_TEXTURE_SIZE_NUMBER =
  TTF_PROP_GPU_TEXT_ENGINE_ATLAS_TEXTURE_SIZE; 
 
} // namespace prop::GpuTextEngine

inline GPUAtlasDrawSequence* GetGPUTextDrawData(TextConstRef text)
{
  return TTF_GetGPUTextDrawData(text);
}
 
inline GPUAtlasDrawSequence* TextBase::GetGPUDrawData() const
{
  return SDL::GetGPUTextDrawData(get());
}

inline void DestroyGPUTextEngine(TextEngineRaw engine)
{
  TTF_DestroyGPUTextEngine(engine);
}
 
inline void GPUTextEngine::Destroy() { DestroyGPUTextEngine(release()); }

inline void SetGPUTextEngineWinding(TextEngineRef engine,
                                    GPUTextEngineWinding winding)
{
  TTF_SetGPUTextEngineWinding(engine, winding);
}
 
inline void GPUTextEngine::SetGPUWinding(GPUTextEngineWinding winding)
{
  SDL::SetGPUTextEngineWinding(get(), winding);
}

inline GPUTextEngineWinding GetGPUTextEngineWinding(TextEngineRef engine)
{
  return TTF_GetGPUTextEngineWinding(engine);
}
 
inline GPUTextEngineWinding GPUTextEngine::GetGPUWinding() const
{
  return SDL::GetGPUTextEngineWinding(get());
}

inline Text CreateText(TextEngineRef engine,
                       FontRef font,
                       std::string_view text)
{
  return Text(engine, font, text);
}
 
inline Text TextEngine::CreateText(FontRef font, std::string_view text)
{
  return Text(get(), font, text);
}
 
inline Text::Text(TextEngineRef engine, FontRef font, std::string_view text)
  : Text(TTF_CreateText(engine, font, text.data(), text.size()))
{
}

inline PropertiesRef GetTextProperties(TextConstRef text)
{
  return {CheckError(TTF_GetTextProperties(text))};
}
 
inline PropertiesRef TextBase::GetProperties() const
{
  return SDL::GetTextProperties(get());
}

inline void SetTextEngine(TextRef text, TextEngineRef engine)
{
  CheckError(TTF_SetTextEngine(text, engine));
}
 
inline void TextBase::SetEngine(TextEngineRef engine)
{
  SDL::SetTextEngine(get(), engine);
}

inline TextEngineRef GetTextEngine(TextConstRef text)
{
  return CheckError(TTF_GetTextEngine(text));
}
 
inline TextEngineRef TextBase::GetEngine() const
{
  return SDL::GetTextEngine(get());
}

inline bool SetTextFont(TextRef text, FontRef font)
{
  return TTF_SetTextFont(text, font);
}
 
inline bool TextBase::SetFont(FontRef font)
{
  return SDL::SetTextFont(get(), font);
}

inline FontRef GetTextFont(TextConstRef text)
{
  return CheckError(TTF_GetTextFont(text));
}
 
inline FontRef TextBase::GetFont() const { return SDL::GetTextFont(get()); }

inline void SetTextDirection(TextRef text, Direction direction)
{
  CheckError(TTF_SetTextDirection(text, direction));
}
 
inline void TextBase::SetDirection(Direction direction)
{
  SDL::SetTextDirection(get(), direction);
}

inline Direction GetTextDirection(TextConstRef text)
{
  return TTF_GetTextDirection(text);
}
 
inline Direction TextBase::GetDirection() const
{
  return SDL::GetTextDirection(get());
}

inline void SetTextScript(TextRef text, Uint32 script)
{
  CheckError(TTF_SetTextScript(text, script));
}
 
inline void TextBase::SetScript(Uint32 script)
{
  SDL::SetTextScript(get(), script);
}

inline Uint32 GetTextScript(TextConstRef text)
{
  return TTF_GetTextScript(text);
}
 
inline Uint32 TextBase::GetScript() const { return SDL::GetTextScript(get()); }

inline void SetTextColor(TextRef text, Color c)
{
  CheckError(TTF_SetTextColor(text, c.r, c.g, c.b, c.a));
}
 
inline void TextBase::SetColor(Color c) { SDL::SetTextColor(get(), c); }

inline void SetTextColorFloat(TextRef text, FColor c)
{
  CheckError(TTF_SetTextColorFloat(text, c.r, c.g, c.b, c.a));
}
 
inline void TextBase::SetColorFloat(FColor c) { SetTextColorFloat(get(), c); }

inline void GetTextColor(TextConstRef text,
                         Uint8* r,
                         Uint8* g,
                         Uint8* b,
                         Uint8* a)
{
  CheckError(TTF_GetTextColor(text, r, g, b, a));
}

inline Color GetTextColor(TextRef text)
{
  Color c;
  GetTextColor(text, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void TextBase::GetColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const
{
  SDL::GetTextColor(get(), r, g, b, a);
}
 
inline Color TextBase::GetColor() const { return SDL::GetTextColor(get()); }

inline void GetTextColorFloat(TextConstRef text,
                              float* r,
                              float* g,
                              float* b,
                              float* a)
{
  CheckError(TTF_GetTextColorFloat(text, r, g, b, a));
}

inline FColor GetTextColorFloat(TextRef text)
{
  FColor c;
  GetTextColorFloat(text, &c.r, &c.g, &c.b, &c.a);
  return c;
}
 
inline void TextBase::GetColorFloat(float* r,
                                    float* g,
                                    float* b,
                                    float* a) const
{
  SDL::GetTextColorFloat(get(), r, g, b, a);
}
 
inline FColor TextBase::GetColorFloat() const
{
  return SDL::GetTextColorFloat(get());
}

inline void SetTextPosition(TextRef text, const PointRaw& p)
{
  CheckError(TTF_SetTextPosition(text, p.x, p.y));
}
 
inline void TextBase::SetPosition(const PointRaw& p)
{
  SDL::SetTextPosition(get(), p);
}

inline void GetTextPosition(TextConstRef text, int* x, int* y)
{
  CheckError(TTF_GetTextPosition(text, x, y));
}

inline Point GetTextPosition(TextRef text)
{
  Point p;
  GetTextPosition(text, &p.x, &p.y);
  return p;
}
 
inline void TextBase::GetPosition(int* x, int* y) const
{
  SDL::GetTextPosition(get(), x, y);
}
 
inline Point TextBase::GetPosition() const { return GetTextPosition(get()); }

inline void SetTextWrapWidth(TextRef text, int wrap_width)
{
  CheckError(TTF_SetTextWrapWidth(text, wrap_width));
}
 
inline void TextBase::SetWrapWidth(int wrap_width)
{
  SDL::SetTextWrapWidth(get(), wrap_width);
}

inline int GetTextWrapWidth(TextConstRef text)
{
  int w;
  CheckError(TTF_GetTextWrapWidth(text, &w));
  return w;
}
 
inline int TextBase::GetWrapWidth() const { return GetTextWrapWidth(get()); }

inline void SetTextWrapWhitespaceVisible(TextRef text, bool visible)
{
  CheckError(TTF_SetTextWrapWhitespaceVisible(text, visible));
}
 
inline void TextBase::SetWrapWhitespaceVisible(bool visible)
{
  SDL::SetTextWrapWhitespaceVisible(get(), visible);
}

inline bool TextWrapWhitespaceVisible(TextConstRef text)
{
  return TTF_TextWrapWhitespaceVisible(text);
}
 
inline bool TextBase::IsWrapWhitespaceVisible() const
{
  return SDL::TextWrapWhitespaceVisible(get());
}

inline void SetTextString(TextRef text, std::string_view string)
{
  CheckError(TTF_SetTextString(text, string.data(), string.size()));
}
 
inline void TextBase::SetString(std::string_view string)
{
  SDL::SetTextString(get(), string);
}

inline void InsertTextString(TextRef text, int offset, std::string_view string)
{
  CheckError(TTF_InsertTextString(text, offset, string.data(), string.size()));
}
 
inline void TextBase::InsertString(int offset, std::string_view string)
{
  SDL::InsertTextString(get(), offset, string);
}

inline void AppendTextString(TextRef text, std::string_view string)
{
  CheckError(TTF_AppendTextString(text, string.data(), string.size()));
}
 
inline void TextBase::AppendString(std::string_view string)
{
  SDL::AppendTextString(get(), string);
}

inline void DeleteTextString(TextRef text, int offset, int length)
{
  CheckError(TTF_DeleteTextString(text, offset, length));
}
 
inline void TextBase::DeleteString(int offset, int length)
{
  SDL::DeleteTextString(get(), offset, length);
}

inline void GetTextSize(TextConstRef text, int* w, int* h)
{
  CheckError(TTF_GetTextSize(text, w, h));
}

inline Point GetTextSize(TextRef text)
{
  Point p;
  GetTextSize(text, &p.x, &p.y);
  return p;
}
 
inline void TextBase::GetSize(int* w, int* h) const
{
  SDL::GetTextSize(get(), w, h);
}
 
inline Point TextBase::GetSize() const { return GetTextSize(get()); }

inline void GetTextSubString(TextConstRef text,
                             int offset,
                             SubString* substring)
{
  CheckError(TTF_GetTextSubString(text, offset, substring));
}
 
inline void TextBase::GetSubString(int offset, SubString* substring) const
{
  SDL::GetTextSubString(get(), offset, substring);
}

inline void GetTextSubStringForLine(TextConstRef text,
                                    int line,
                                    SubString* substring)
{
  CheckError(TTF_GetTextSubStringForLine(text, line, substring));
}
 
inline void TextBase::GetSubStringForLine(int line, SubString* substring) const
{
  SDL::GetTextSubStringForLine(get(), line, substring);
}

inline OwnArray<SubString*> GetTextSubStringsForRange(TextConstRef text,
                                                      int offset,
                                                      int length)
{
  int count = 0;
  auto data = TTF_GetTextSubStringsForRange(text, offset, length, &count);
  return OwnArray<SubString*>{data, size_t(count)};
}
 
inline OwnArray<SubString*> TextBase::GetSubStringsForRange(int offset,
                                                            int length) const
{
  return SDL::GetTextSubStringsForRange(get(), offset, length);
}

inline void GetTextSubStringForPoint(TextConstRef text,
                                     Point p,
                                     SubString* substring)
{
  CheckError(TTF_GetTextSubStringForPoint(text, p.x, p.y, substring));
}
 
inline void TextBase::GetSubStringForPoint(Point p, SubString* substring) const
{
  SDL::GetTextSubStringForPoint(get(), p, substring);
}

inline void GetPreviousTextSubString(TextConstRef text,
                                     const SubString& substring,
                                     SubString* previous)
{
  CheckError(TTF_GetPreviousTextSubString(text, &substring, previous));
}
 
inline void TextBase::GetPreviousSubString(const SubString& substring,
                                           SubString* previous) const
{
  SDL::GetPreviousTextSubString(get(), substring, previous);
}

inline void GetNextTextSubString(TextConstRef text,
                                 const SubString& substring,
                                 SubString* next)
{
  CheckError(TTF_GetNextTextSubString(text, &substring, next));
}
 
inline void TextBase::GetNextSubString(const SubString& substring,
                                       SubString* next) const
{
  SDL::GetNextTextSubString(get(), substring, next);
}

inline void UpdateText(TextRef text) { CheckError(TTF_UpdateText(text)); }
 
inline void TextBase::Update() { SDL::UpdateText(get()); }

inline void DestroyText(TextRaw text) { TTF_DestroyText(text); }
 
inline void TextBase::Destroy() { DestroyText(release()); }

inline void CloseFont(FontRaw font) { TTF_CloseFont(font); }
 
inline void FontBase::Close() { CloseFont(release()); }

 
} // namespace SDL
 
#endif // defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_TTF_H_ */