SDL3pp_ttf.h

#ifndef SDL3PP_TTF_H_
#define SDL3PP_TTF_H_
 
#include "SDL3pp_error.h"
#include "SDL3pp_init.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_render.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_version.h"
 
#if !defined(SDL3PP_DISABLE_TTF) && !defined(SDL3PP_ENABLE_TTF) &&             \
  __has_include(<SDL3_ttf/SDL_ttf.h>)
#define SDL3PP_ENABLE_TTF
#endif
 
#if defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#include <SDL3_ttf/SDL_ttf.h>
 
namespace SDL {
 
constexpr struct TtfInitFlag : InitFlagsExtra
{
} INIT_TTF; 
 
// Forward decl
struct FontBase;
 
// Forward decl
struct FontRef;
 
// Forward decl
struct Font;
 
// Forward decl
struct TextEngineBase;
 
// Forward decl
struct TextEngineRef;
 
// Forward decl
struct TextEngine;
 
// Forward decl
struct TextBase;
 
// Forward decl
struct TextRef;
 
// Forward decl
struct Text;
 
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;
 
constexpr HintingFlags HINTING_INVALID = TTF_HINTING_INVALID; 
 
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;
 
 
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; 
 
 
#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
 
inline int TTF_Version() { return ::TTF_Version(); }
 
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 TextData = TTF_TextData;
 
struct FontBase : Resource<TTF_Font*>
{
  using Resource::Resource;
 
  FontBase(StringParam file, float ptsize)
    : Resource(CheckError(TTF_OpenFont(file, ptsize)))
  {
  }
 
  FontBase(IOStreamBase& src, float ptsize)
    : Resource(CheckError(TTF_OpenFontIO(src.get(), false, ptsize)))
  {
  }
 
  FontBase(PropertiesBase& props)
    : Resource(CheckError(TTF_OpenFontWithProperties(props.get())))
  {
  }
 
  Font Copy() const;
 
  PropertiesRef GetProperties()
  {
    return CheckError(TTF_GetFontProperties(get()));
  }
 
  Uint32 GetGeneration() const { return TTF_GetFontGeneration(get()); }
 
  void AddFallback(FontBase& fallback)
  {
    CheckError(TTF_AddFallbackFont(get(), fallback.get()));
  }
 
  void RemoveFallback(FontBase& fallback)
  {
    TTF_RemoveFallbackFont(get(), fallback.get());
  }
 
  void ClearFallbacks() { TTF_ClearFallbackFonts(get()); }
 
  void SetSize(float ptsize) { CheckError(TTF_SetFontSize(get(), ptsize)); }
 
  void SetSizeDPI(float ptsize, int hdpi, int vdpi)
  {
    CheckError(TTF_SetFontSizeDPI(get(), ptsize, hdpi, vdpi));
  }
 
  float GetSize() const { return TTF_GetFontSize(get()); }
 
  void GetDPI(int* hdpi, int* vdpi) const
  {
    CheckError(TTF_GetFontDPI(get(), hdpi, vdpi));
  }
 
  void SetStyle(FontStyleFlags style) { TTF_SetFontStyle(get(), style); }
 
  FontStyleFlags GetStyle() const { return TTF_GetFontStyle(get()); }
 
  void SetOutline(int outline)
  {
    CheckError(TTF_SetFontOutline(get(), outline));
  }
 
  int GetOutline() const { return TTF_GetFontOutline(get()); }
 
  void SetHinting(HintingFlags hinting) { TTF_SetFontHinting(get(), hinting); }
 
  int GetNumFaces() const { return TTF_GetNumFontFaces(get()); }
 
  HintingFlags GetHinting() const { return TTF_GetFontHinting(get()); }
 
  void SetSDF(bool enabled) { CheckError(TTF_SetFontSDF(get(), enabled)); }
 
  bool GetSDF() const { return TTF_GetFontSDF(get()); }
 
#if SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
  int GetWeight() const { return TTF_GetFontWeight(get()); }
 
#endif // SDL_TTF_VERSION_ATLEAST(3, 2, 2)
 
  void SetWrapAlignment(HorizontalAlignment align)
  {
    TTF_SetFontWrapAlignment(get(), align);
  }
 
  HorizontalAlignment GetWrapAlignment() const
  {
    return TTF_GetFontWrapAlignment(get());
  }
 
  int GetHeight() const { return TTF_GetFontHeight(get()); }
 
  int GetAscent() const { return TTF_GetFontAscent(get()); }
 
  int GetDescent() const { return TTF_GetFontDescent(get()); }
 
  void SetLineSkip(int lineskip) { TTF_SetFontLineSkip(get(), lineskip); }
 
  int GetLineSkip() const { return TTF_GetFontLineSkip(get()); }
 
  void SetKerning(bool enabled) { TTF_SetFontKerning(get(), enabled); }
 
  bool GetKerning() const { return TTF_GetFontKerning(get()); }
 
  bool IsFixedWidth() const { return TTF_FontIsFixedWidth(get()); }
 
  bool IsScalable() const { return TTF_FontIsScalable(get()); }
 
  const char* GetFamilyName() const { return TTF_GetFontFamilyName(get()); }
 
  const char* GetStyleName() const { return TTF_GetFontStyleName(get()); }
 
  void SetDirection(Direction direction)
  {
    CheckError(TTF_SetFontDirection(get(), direction));
  }
 
  Direction GetDirection() const { return TTF_GetFontDirection(get()); }
 
  void SetScript(Uint32 script)
  {
    CheckError(TTF_SetFontScript(get(), script));
  }
 
  Uint32 GetScript() const { return TTF_GetFontScript(get()); }
 
  static Uint32 GetGlyphScript(Uint32 ch) { return TTF_GetGlyphScript(ch); }
 
  void SetLanguage(StringParam language_bcp47)
  {
    CheckError(TTF_SetFontLanguage(get(), language_bcp47));
  }
 
  bool HasGlyph(Uint32 ch) const { return TTF_FontHasGlyph(get(), ch); }
 
  SurfaceRef GetGlyphImage(Uint32 ch, ImageType* image_type = nullptr) const
  {
    return TTF_GetGlyphImage(get(), ch, image_type);
  }
 
  SurfaceRef GetGlyphImageForIndex(Uint32 glyph_index,
                                   ImageType* image_type = nullptr) const
  {
    return TTF_GetGlyphImageForIndex(get(), glyph_index, image_type);
  }
 
  void GetGlyphMetrics(Uint32 ch,
                       int* minx,
                       int* maxx,
                       int* miny,
                       int* maxy,
                       int* advance) const
  {
    CheckError(TTF_GetGlyphMetrics(get(), ch, minx, maxx, miny, maxy, advance));
  }
 
  int GetGlyphKerning(Uint32 previous_ch, Uint32 ch) const
  {
    if (int r; TTF_GetGlyphKerning(get(), previous_ch, ch, &r)) return r;
    throw Error();
  }
 
  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
  {
    CheckError(TTF_GetStringSize(get(), text.data(), text.size(), w, h));
  }
 
  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
  {
    CheckError(TTF_GetStringSizeWrapped(
      get(), text.data(), text.size(), wrap_width, w, h));
  }
 
  void MeasureString(std::string_view text,
                     int max_width,
                     int* measured_width,
                     size_t* measured_length) const
  {
    CheckError(TTF_MeasureString(get(),
                                 text.data(),
                                 text.size(),
                                 max_width,
                                 measured_width,
                                 measured_length));
  }
 
  Surface RenderText_Solid(std::string_view text, Color fg) const
  {
    return Surface{TTF_RenderText_Solid(get(), text.data(), text.size(), fg)};
  }
 
  Surface RenderText_Solid_Wrapped(std::string_view text,
                                   Color fg,
                                   int wrapLength) const
  {
    return Surface{TTF_RenderText_Solid_Wrapped(
      get(), text.data(), text.size(), fg, wrapLength)};
  }
 
  Surface RenderGlyph_Solid(Uint32 ch, Color fg) const
  {
    return Surface{TTF_RenderGlyph_Solid(get(), ch, fg)};
  }
 
  Surface RenderText_Shaded(std::string_view text, Color fg, Color bg) const
  {
    return Surface{
      TTF_RenderText_Shaded(get(), text.data(), text.size(), fg, bg)};
  }
 
  Surface RenderText_Shaded_Wrapped(std::string_view text,
                                    Color fg,
                                    Color bg,
                                    int wrap_width) const
  {
    return Surface{TTF_RenderText_Shaded_Wrapped(
      get(), text.data(), text.size(), fg, bg, wrap_width)};
  }
 
  Surface RenderGlyph_Shaded(Uint32 ch, Color fg, Color bg) const
  {
    return Surface{TTF_RenderGlyph_Shaded(get(), ch, fg, bg)};
  }
 
  Surface RenderText_Blended(std::string_view text, Color fg) const
  {
    return Surface{TTF_RenderText_Blended(get(), text.data(), text.size(), fg)};
  }
 
  Surface RenderText_Blended_Wrapped(std::string_view text,
                                     Color fg,
                                     int wrap_width) const
  {
    return Surface{TTF_RenderText_Blended_Wrapped(
      get(), text.data(), text.size(), fg, wrap_width)};
  }
 
  Surface RenderGlyph_Blended(Uint32 ch, Color fg) const
  {
    return Surface{TTF_RenderGlyph_Blended(get(), ch, fg)};
  }
 
  Surface RenderText_LCD(std::string_view text, Color fg, Color bg) const
  {
    return Surface{TTF_RenderText_LCD(get(), text.data(), text.size(), fg, bg)};
  }
 
  Surface RenderText_LCD_Wrapped(std::string_view text,
                                 Color fg,
                                 Color bg,
                                 int wrap_width) const
  {
    return Surface{TTF_RenderText_LCD_Wrapped(
      get(), text.data(), text.size(), fg, bg, wrap_width)};
  }
 
  Surface RenderGlyph_LCD(Uint32 ch, Color fg, Color bg) const
  {
    return Surface{TTF_RenderGlyph_LCD(get(), ch, fg, bg)};
  }
};
 
struct FontRef : FontBase
{
  using FontBase::FontBase;
 
  constexpr FontRef(const FontRef& other)
    : FontBase(other.get())
  {
  }
 
  constexpr FontRef(FontRef&& other)
    : FontBase(other.release())
  {
  }
 
  constexpr ~FontRef() = default;
 
  FontRef& operator=(FontRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(TTF_Font* newResource = {})
  {
    TTF_CloseFont(release(newResource));
  }
};
 
struct Font : FontRef
{
  using FontRef::FontRef;
 
  constexpr explicit Font(TTF_Font* resource = {})
    : FontRef(resource)
  {
  }
 
  constexpr Font(const Font& other) = delete;
 
  constexpr Font(Font&& other) = default;
 
  ~Font() { reset(); }
 
  Font& operator=(Font other)
  {
    reset(other.release());
    return *this;
  }
};
 
inline void InitSubSystem(TtfInitFlag _) { CheckError(TTF_Init()); }
 
struct TextEngineBase : Resource<TTF_TextEngine*>
{
  using Resource::Resource;
 
protected:
  void (*m_destroy)(TTF_TextEngine* engine) = nullptr;
 
public:
  constexpr TextEngineBase(TTF_TextEngine* engine,
                           void (*destroy)(TTF_TextEngine* engine))
    : Resource(engine)
    , m_destroy(destroy)
  {
  }
 
  void SetGPUWinding(GPUTextEngineWinding winding)
  {
    TTF_SetGPUTextEngineWinding(get(), winding);
  }
 
  GPUTextEngineWinding GetGPUWinding() const
  {
    return TTF_GetGPUTextEngineWinding(get());
  }
};
 
struct TextEngineRef : TextEngineBase
{
  using TextEngineBase::TextEngineBase;
 
  constexpr TextEngineRef(const TextEngineRef& other)
    : TextEngineBase(other.get(), other.m_destroy)
  {
  }
 
  constexpr TextEngineRef(TextEngineRef&& other)
    : TextEngineBase(other.release(), other.m_destroy)
  {
  }
 
  constexpr ~TextEngineRef() = default;
 
  TextEngineRef& operator=(TextEngineRef other)
  {
    release(other.release());
    m_destroy = other.m_destroy;
    other.m_destroy = nullptr;
    return *this;
  }
 
  void reset(TTF_TextEngine* newResource = {})
  {
    auto prevValue = release(newResource);
    if (m_destroy) m_destroy(prevValue);
    m_destroy = nullptr;
  }
};
 
struct TextEngine : TextEngineRef
{
  using TextEngineRef::TextEngineRef;
 
  constexpr explicit TextEngine(TTF_TextEngine* resource = {})
    : TextEngineRef(resource)
  {
  }
 
  constexpr TextEngine(const TextEngine& other) = delete;
 
  constexpr TextEngine(TextEngine&& other) = default;
 
  ~TextEngine() { reset(); }
 
  TextEngine& operator=(TextEngine other)
  {
    reset(other.release());
    m_destroy = other.m_destroy;
    other.m_destroy = nullptr;
    return *this;
  }
};
 
using GPUAtlasDrawSequence = TTF_GPUAtlasDrawSequence;
 
using SubString = TTF_SubString;
 
// Forward decl
struct SubStringIterator;
 
namespace prop::Font {
 
constexpr auto CREATE_FILENAME_STRING = TTF_PROP_FONT_CREATE_FILENAME_STRING;
 
constexpr auto CREATE_IOSTREAM_POINTER = TTF_PROP_FONT_CREATE_IOSTREAM_POINTER;
 
constexpr auto CREATE_IOSTREAM_OFFSET_NUMBER =
  TTF_PROP_FONT_CREATE_IOSTREAM_OFFSET_NUMBER;
 
constexpr auto CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN =
  TTF_PROP_FONT_CREATE_IOSTREAM_AUTOCLOSE_BOOLEAN;
 
constexpr auto CREATE_SIZE_FLOAT = TTF_PROP_FONT_CREATE_SIZE_FLOAT;
 
constexpr auto CREATE_FACE_NUMBER = TTF_PROP_FONT_CREATE_FACE_NUMBER;
 
constexpr auto CREATE_HORIZONTAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_HORIZONTAL_DPI_NUMBER;
 
constexpr auto CREATE_VERTICAL_DPI_NUMBER =
  TTF_PROP_FONT_CREATE_VERTICAL_DPI_NUMBER;
 
constexpr auto CREATE_EXISTING_FONT = TTF_PROP_FONT_CREATE_EXISTING_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 Font FontBase::Copy() const { return Font{TTF_CopyFont(get())}; }
 
#ifdef SDL3PP_DOC
 
#define SDL_FONT_WEIGHT_THIN TTF_FONT_WEIGHT_THIN
 
#define SDL_FONT_WEIGHT_EXTRA_LIGHT TTF_FONT_WEIGHT_EXTRA_LIGHT
 
#define SDL_FONT_WEIGHT_LIGHT TTF_FONT_WEIGHT_LIGHT
 
#define SDL_FONT_WEIGHT_NORMAL TTF_FONT_WEIGHT_NORMAL
 
#define SDL_FONT_WEIGHT_MEDIUM TTF_FONT_WEIGHT_MEDIUM
 
#define SDL_FONT_WEIGHT_SEMI_BOLD TTF_FONT_WEIGHT_SEMI_BOLD
 
#define SDL_FONT_WEIGHT_BOLD TTF_FONT_WEIGHT_BOLD
 
#define SDL_FONT_WEIGHT_EXTRA_BOLD TTF_FONT_WEIGHT_EXTRA_BOLD
 
#define SDL_FONT_WEIGHT_BLACK TTF_FONT_WEIGHT_BLACK
 
#define SDL_FONT_WEIGHT_EXTRA_BLACK TTF_FONT_WEIGHT_EXTRA_BLACK
 
#endif // SDL3PP_DOC
 
inline Uint32 StringToTag(StringParam string)
{
  return TTF_StringToTag(string);
}
 
inline void TagToString(Uint32 tag, char* string, size_t size)
{
  TTF_TagToString(tag, string, size);
}
 
struct TextBase : Resource<TTF_Text*>
{
  using Resource::Resource;
 
  void DrawSurface(Point p, SurfaceRef surface) const
  {
    CheckError(TTF_DrawSurfaceText(get(), p.x, p.y, surface.get()));
  }
 
  void DrawRenderer(FPoint p) const
  {
    CheckError(TTF_DrawRendererText(get(), p.x, p.y));
  }
 
  GPUAtlasDrawSequence* GetGPUDrawData() const
  {
    return TTF_GetGPUTextDrawData(get());
  }
 
  TextBase(TextEngineBase& engine, FontRef font, std::string_view text)
    : Resource(
        TTF_CreateText(engine.get(), font.get(), text.data(), text.size()))
  {
  }
 
  PropertiesRef GetProperties() const
  {
    return CheckError(TTF_GetTextProperties(get()));
  }
 
  void SetEngine(TextEngineBase& engine)
  {
    CheckError(TTF_SetTextEngine(get(), engine.get()));
  }
 
  TextEngineRef GetEngine() const
  {
    return CheckError(TTF_GetTextEngine(get()));
  }
 
  bool SetFont(FontBase& font) { return TTF_SetTextFont(get(), font.get()); }
 
  FontRef GetFont() const { return CheckError(TTF_GetTextFont(get())); }
 
  void SetDirection(Direction direction)
  {
    CheckError(TTF_SetTextDirection(get(), direction));
  }
 
  Direction GetDirection() const { return TTF_GetTextDirection(get()); }
 
  void SetScript(Uint32 script)
  {
    CheckError(TTF_SetTextScript(get(), script));
  }
 
  Uint32 GetScript() const { return TTF_GetTextScript(get()); }
 
  void SetColor(Color c)
  {
    CheckError(TTF_SetTextColor(get(), c.r, c.g, c.b, c.a));
  }
 
  void SetColor(FColor c)
  {
    CheckError(TTF_SetTextColorFloat(get(), c.r, c.g, c.b, c.a));
  }
 
  FColor GetColor() const
  {
    FColor c;
    GetColor(&c);
    return c;
  }
 
  void GetColor(Color* c) const
  {
    SDL_assert_paranoid(c != nullptr);
    GetColor(&c->r, &c->g, &c->b, &c->a);
  }
 
  void GetColor(FColor* c) const
  {
    SDL_assert_paranoid(c != nullptr);
    GetColor(&c->r, &c->g, &c->b, &c->a);
  }
 
  void GetColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const
  {
    CheckError(TTF_GetTextColor(get(), r, g, b, a));
  }
 
  void GetColor(float* r, float* g, float* b, float* a) const
  {
    CheckError(TTF_GetTextColorFloat(get(), r, g, b, a));
  }
 
  bool SetPosition(Point p) { return TTF_SetTextPosition(get(), p.x, p.y); }
 
  Point GetPosition() const
  {
    Point p;
    GetPosition(&p.x, &p.y);
    return p;
  }
 
  bool GetPosition(int* x, int* y) const
  {
    return TTF_GetTextPosition(get(), x, y);
  }
 
  void SetWrapWidth(int wrap_width)
  {
    CheckError(TTF_SetTextWrapWidth(get(), wrap_width));
  }
 
  int GetWrapWidth() const
  {
    int w;
    CheckError(TTF_GetTextWrapWidth(get(), &w));
    return w;
  }
 
  void SetWrapWhitespaceVisible(bool visible)
  {
    CheckError(TTF_SetTextWrapWhitespaceVisible(get(), visible));
  }
 
  bool IsWrapWhitespaceVisible() const
  {
    return TTF_TextWrapWhitespaceVisible(get());
  }
 
  void SetString(std::string_view string)
  {
    CheckError(TTF_SetTextString(get(), string.data(), string.size()));
  }
 
  void InsertString(int offset, std::string_view string)
  {
    CheckError(
      TTF_InsertTextString(get(), offset, string.data(), string.size()));
  }
 
  void AppendString(std::string_view string)
  {
    CheckError(TTF_AppendTextString(get(), string.data(), string.size()));
  }
 
  void DeleteString(int offset, int length = -1)
  {
    CheckError(TTF_DeleteTextString(get(), offset, length));
  }
 
  Point GetSize() const
  {
    Point p;
    GetSize(&p.x, &p.y);
    return p;
  }
 
  void GetSize(int* w, int* h) const
  {
    CheckError(TTF_GetTextSize(get(), w, h));
  }
 
  void GetSubString(int offset, SubString* substring) const
  {
    CheckError(TTF_GetTextSubString(get(), offset, substring));
  }
 
  SubStringIterator begin() const;
 
  SubStringIterator end() const;
 
  SubStringIterator GetSubStringForLine(int line) const;
 
  void GetSubStringForLine(int line, SubString* substring) const
  {
    CheckError(TTF_GetTextSubStringForLine(get(), line, substring));
  }
 
  OwnArray<SubString*> GetSubStrings() const
  {
    return GetSubStringsForRange(0);
  }
 
  OwnArray<SubString*> GetSubStringsForRange(int offset, int length = -1) const
  {
    int count = 0;
    auto data = TTF_GetTextSubStringsForRange(get(), offset, length, &count);
    return OwnArray<SubString*>{data, size_t(count)};
  }
 
  SubStringIterator GetSubStringForPoint(Point p) const;
 
  void GetSubStringForPoint(Point p, SubString* substring) const
  {
    CheckError(TTF_GetTextSubStringForPoint(get(), p.x, p.y, substring));
  }
 
  void GetPreviousSubString(const SubString& substring,
                            SubString* previous) const
  {
    CheckError(TTF_GetPreviousTextSubString(get(), &substring, previous));
  }
 
  void GetNextSubString(const SubString& substring, SubString* next) const
  {
    CheckError(TTF_GetNextTextSubString(get(), &substring, next));
  }
 
  void Update() { CheckError(TTF_UpdateText(get())); }
 
  const char* GetText() const { return get()->text; }
 
  int GetNumLines() const { return get()->num_lines; }
};
 
struct TextRef : TextBase
{
  using TextBase::TextBase;
 
  constexpr TextRef(const TextRef& other)
    : TextBase(other.get())
  {
  }
 
  constexpr TextRef(TextRef&& other)
    : TextBase(other.release())
  {
  }
 
  constexpr ~TextRef() = default;
 
  TextRef& operator=(TextRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(TTF_Text* newResource = {})
  {
    TTF_DestroyText(release(newResource));
  }
};
 
struct Text : TextRef
{
  using TextRef::TextRef;
 
  constexpr explicit Text(TTF_Text* resource = {})
    : TextRef(resource)
  {
  }
 
  constexpr Text(const Text& other) = delete;
 
  constexpr Text(Text&& other) = default;
 
  ~Text() { reset(); }
 
  Text& operator=(Text other)
  {
    reset(other.release());
    return *this;
  }
};
 
class SubStringIterator
{
  TextRef m_text;
 
  SubString m_subString;
 
  constexpr SubStringIterator(TextRef text)
    : m_text(std::move(text))
    , m_subString(0)
  {
  }
 
public:
  constexpr SubStringIterator()
    : SubStringIterator(nullptr)
  {
  }
 
  constexpr operator bool() const { return m_text != nullptr; }
 
  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;
  }
 
  constexpr SubStringIterator& operator++()
  {
    m_text.GetNextSubString(m_subString, &m_subString);
    return *this;
  }
 
  constexpr SubStringIterator operator++(int)
  {
    auto curr = *this;
    m_text.GetNextSubString(m_subString, &m_subString);
    return curr;
  }
 
  constexpr SubStringIterator& operator--()
  {
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return *this;
  }
 
  constexpr SubStringIterator operator--(int)
  {
    auto curr = *this;
    m_text.GetPreviousSubString(m_subString, &m_subString);
    return curr;
  }
 
  friend class TextBase;
};
 
inline TextEngine CreateSurfaceTextEngine()
{
  return TextEngine{TTF_CreateSurfaceTextEngine(),
                    TTF_DestroySurfaceTextEngine};
}
 
inline TextEngine CreateRendererTextEngine(RendererBase& renderer)
{
  return TextEngine{TTF_CreateRendererTextEngine(renderer.get()),
                    TTF_DestroyRendererTextEngine};
}
 
inline TextEngine CreateRendererTextEngineWithProperties(PropertiesBase& props)
{
  return TextEngine{TTF_CreateRendererTextEngineWithProperties(props.get()),
                    TTF_DestroyRendererTextEngine};
}
 
namespace prop::RendererTextEngine {
 
constexpr auto RENDERER = TTF_PROP_RENDERER_TEXT_ENGINE_RENDERER;
 
constexpr auto ATLAS_TEXTURE_SIZE =
  TTF_PROP_RENDERER_TEXT_ENGINE_ATLAS_TEXTURE_SIZE;
 
} // namespace prop::RendererTextEngine
 
inline TextEngine CreateGPUTextEngine(SDL_GPUDevice* device)
{
  return TextEngine{TTF_CreateGPUTextEngine(device), TTF_DestroyGPUTextEngine};
}
 
inline TextEngine CreateGPUTextEngineWithProperties(PropertiesBase& props)
{
  return TextEngine{TTF_CreateGPUTextEngineWithProperties(props.get()),
                    TTF_DestroyGPUTextEngine};
}
 
namespace prop::GpuTextEngine {
 
constexpr auto DEVICE = TTF_PROP_GPU_TEXT_ENGINE_DEVICE;
 
constexpr auto ATLAS_TEXTURE_SIZE = TTF_PROP_GPU_TEXT_ENGINE_ATLAS_TEXTURE_SIZE;
 
} // namespace prop::GpuTextEngine
 
inline void QuitSubSystem(TtfInitFlag _) { TTF_Quit(); }
 
inline int WasInit(TtfInitFlag _) { return TTF_WasInit(); }
 
 
#pragma region impl
 
inline SubStringIterator TextBase::begin() const
{
  SubStringIterator it{get()};
  GetSubString(0, &it.m_subString);
  return it;
}
 
inline SubStringIterator TextBase::end() const
{
  SubStringIterator it{get()};
  GetSubString(INT_MAX, &it.m_subString);
  return it;
}
 
inline SubStringIterator TextBase::GetSubStringForLine(int line) const
{
  SubStringIterator it{get()};
  GetSubStringForLine(line, &it.m_subString);
  return it;
}
 
inline SubStringIterator TextBase::GetSubStringForPoint(Point p) const
{
  SubStringIterator it{get()};
  GetSubStringForPoint(p, &it.m_subString);
  return it;
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif // defined(SDL3PP_ENABLE_TTF) || defined(SDL3PP_DOC)
 
#endif /* SDL3PP_TTF_H_ */