ft2font_wrapper.cpp

#defineNPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include<pybind11/pybind11.h>
#include<pybind11/numpy.h>
#include<pybind11/stl.h>

#include"ft2font.h"
#include"_enums.h"

#include<set>
#include<sstream>
#include<unordered_map>

namespacepy= pybind11;
usingnamespacepybind11::literals;

template <typename T>
using double_or_ = std::variant<double, T>;

template <typename T>
static T
_double_to_(constchar *name, double_or_<T> &var)
{
if (auto value = std::get_if<double>(&var)) {
auto api = py::module_::import("matplotlib._api");
auto warn = api.attr("warn_deprecated");
warn("since"_a="3.10", "name"_a=name, "obj_type"_a="parameter as float",
"alternative"_a="int({})"_s.format(name));
returnstatic_cast<T>(*value);
 } elseif (auto value = std::get_if<T>(&var)) {
return *value;
 } else {
// pybind11 will have only allowed types that match the variant, so this `else`
// can't happen. We only have this case because older macOS doesn't support
// `std::get` and using the conditional `std::get_if` means an `else` to silence
// compiler warnings about "unhandled" cases.
throwstd::runtime_error("Should not happen");
 }
}

/**********************************************************************
 * Enumerations
 * */

constchar *Kerning__doc__ = R"""(
 Kerning modes for `.FT2Font.get_kerning`.

 For more information, see `the FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_kerning_mode>`_.

 .. versionadded:: 3.10
)""";

P11X_DECLARE_ENUM(
"Kerning", "Enum",
 {"DEFAULT", FT_KERNING_DEFAULT},
 {"UNFITTED", FT_KERNING_UNFITTED},
 {"UNSCALED", FT_KERNING_UNSCALED},
);

constchar *FaceFlags__doc__ = R"""(
 Flags returned by `FT2Font.face_flags`.

 For more information, see `the FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_face_flag_xxx>`_.

 .. versionadded:: 3.10
)""";

#ifndef FT_FACE_FLAG_VARIATION // backcompat: ft 2.9.0.
#defineFT_FACE_FLAG_VARIATION (1L << 15)
#endif
#ifndef FT_FACE_FLAG_SVG // backcompat: ft 2.12.0.
#defineFT_FACE_FLAG_SVG (1L << 16)
#endif
#ifndef FT_FACE_FLAG_SBIX // backcompat: ft 2.12.0.
#defineFT_FACE_FLAG_SBIX (1L << 17)
#endif
#ifndef FT_FACE_FLAG_SBIX_OVERLAY // backcompat: ft 2.12.0.
#defineFT_FACE_FLAG_SBIX_OVERLAY (1L << 18)
#endif

enumclassFaceFlags : FT_Long {
#defineDECLARE_FLAG(name) name = FT_FACE_FLAG_##name
DECLARE_FLAG(SCALABLE),
DECLARE_FLAG(FIXED_SIZES),
DECLARE_FLAG(FIXED_WIDTH),
DECLARE_FLAG(SFNT),
DECLARE_FLAG(HORIZONTAL),
DECLARE_FLAG(VERTICAL),
DECLARE_FLAG(KERNING),
DECLARE_FLAG(FAST_GLYPHS),
DECLARE_FLAG(MULTIPLE_MASTERS),
DECLARE_FLAG(GLYPH_NAMES),
DECLARE_FLAG(EXTERNAL_STREAM),
DECLARE_FLAG(HINTER),
DECLARE_FLAG(CID_KEYED),
DECLARE_FLAG(TRICKY),
DECLARE_FLAG(COLOR),
DECLARE_FLAG(VARIATION),
DECLARE_FLAG(SVG),
DECLARE_FLAG(SBIX),
DECLARE_FLAG(SBIX_OVERLAY),
#undef DECLARE_FLAG
};

P11X_DECLARE_ENUM(
"FaceFlags", "Flag",
 {"SCALABLE", FaceFlags::SCALABLE},
 {"FIXED_SIZES", FaceFlags::FIXED_SIZES},
 {"FIXED_WIDTH", FaceFlags::FIXED_WIDTH},
 {"SFNT", FaceFlags::SFNT},
 {"HORIZONTAL", FaceFlags::HORIZONTAL},
 {"VERTICAL", FaceFlags::VERTICAL},
 {"KERNING", FaceFlags::KERNING},
 {"FAST_GLYPHS", FaceFlags::FAST_GLYPHS},
 {"MULTIPLE_MASTERS", FaceFlags::MULTIPLE_MASTERS},
 {"GLYPH_NAMES", FaceFlags::GLYPH_NAMES},
 {"EXTERNAL_STREAM", FaceFlags::EXTERNAL_STREAM},
 {"HINTER", FaceFlags::HINTER},
 {"CID_KEYED", FaceFlags::CID_KEYED},
 {"TRICKY", FaceFlags::TRICKY},
 {"COLOR", FaceFlags::COLOR},
 {"VARIATION", FaceFlags::VARIATION},
 {"SVG", FaceFlags::SVG},
 {"SBIX", FaceFlags::SBIX},
 {"SBIX_OVERLAY", FaceFlags::SBIX_OVERLAY},
);

constchar *LoadFlags__doc__ = R"""(
 Flags for `FT2Font.load_char`, `FT2Font.load_glyph`, and `FT2Font.set_text`.

 For more information, see `the FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>`_.

 .. versionadded:: 3.10
)""";

#ifndef FT_LOAD_COMPUTE_METRICS // backcompat: ft 2.6.1.
#defineFT_LOAD_COMPUTE_METRICS (1L << 21)
#endif
#ifndef FT_LOAD_BITMAP_METRICS_ONLY // backcompat: ft 2.7.1.
#defineFT_LOAD_BITMAP_METRICS_ONLY (1L << 22)
#endif
#ifndef FT_LOAD_NO_SVG // backcompat: ft 2.13.1.
#defineFT_LOAD_NO_SVG (1L << 24)
#endif

enumclassLoadFlags : FT_Int32 {
#defineDECLARE_FLAG(name) name = FT_LOAD_##name
DECLARE_FLAG(DEFAULT),
DECLARE_FLAG(NO_SCALE),
DECLARE_FLAG(NO_HINTING),
DECLARE_FLAG(RENDER),
DECLARE_FLAG(NO_BITMAP),
DECLARE_FLAG(VERTICAL_LAYOUT),
DECLARE_FLAG(FORCE_AUTOHINT),
DECLARE_FLAG(CROP_BITMAP),
DECLARE_FLAG(PEDANTIC),
DECLARE_FLAG(IGNORE_GLOBAL_ADVANCE_WIDTH),
DECLARE_FLAG(NO_RECURSE),
DECLARE_FLAG(IGNORE_TRANSFORM),
DECLARE_FLAG(MONOCHROME),
DECLARE_FLAG(LINEAR_DESIGN),
DECLARE_FLAG(NO_AUTOHINT),
DECLARE_FLAG(COLOR),
DECLARE_FLAG(COMPUTE_METRICS),
DECLARE_FLAG(BITMAP_METRICS_ONLY),
DECLARE_FLAG(NO_SVG),
DECLARE_FLAG(TARGET_NORMAL),
DECLARE_FLAG(TARGET_LIGHT),
DECLARE_FLAG(TARGET_MONO),
DECLARE_FLAG(TARGET_LCD),
DECLARE_FLAG(TARGET_LCD_V),
#undef DECLARE_FLAG
};

P11X_DECLARE_ENUM(
"LoadFlags", "Flag",
 {"DEFAULT", LoadFlags::DEFAULT},
 {"NO_SCALE", LoadFlags::NO_SCALE},
 {"NO_HINTING", LoadFlags::NO_HINTING},
 {"RENDER", LoadFlags::RENDER},
 {"NO_BITMAP", LoadFlags::NO_BITMAP},
 {"VERTICAL_LAYOUT", LoadFlags::VERTICAL_LAYOUT},
 {"FORCE_AUTOHINT", LoadFlags::FORCE_AUTOHINT},
 {"CROP_BITMAP", LoadFlags::CROP_BITMAP},
 {"PEDANTIC", LoadFlags::PEDANTIC},
 {"IGNORE_GLOBAL_ADVANCE_WIDTH", LoadFlags::IGNORE_GLOBAL_ADVANCE_WIDTH},
 {"NO_RECURSE", LoadFlags::NO_RECURSE},
 {"IGNORE_TRANSFORM", LoadFlags::IGNORE_TRANSFORM},
 {"MONOCHROME", LoadFlags::MONOCHROME},
 {"LINEAR_DESIGN", LoadFlags::LINEAR_DESIGN},
 {"NO_AUTOHINT", LoadFlags::NO_AUTOHINT},
 {"COLOR", LoadFlags::COLOR},
 {"COMPUTE_METRICS", LoadFlags::COMPUTE_METRICS},
 {"BITMAP_METRICS_ONLY", LoadFlags::BITMAP_METRICS_ONLY},
 {"NO_SVG", LoadFlags::NO_SVG},
// These must be unique, but the others can be OR'd together; I don't know if
// there's any way to really enforce that.
 {"TARGET_NORMAL", LoadFlags::TARGET_NORMAL},
 {"TARGET_LIGHT", LoadFlags::TARGET_LIGHT},
 {"TARGET_MONO", LoadFlags::TARGET_MONO},
 {"TARGET_LCD", LoadFlags::TARGET_LCD},
 {"TARGET_LCD_V", LoadFlags::TARGET_LCD_V},
);

constchar *StyleFlags__doc__ = R"""(
 Flags returned by `FT2Font.style_flags`.

 For more information, see `the FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-face_creation.html#ft_style_flag_xxx>`_.

 .. versionadded:: 3.10
)""";

enumclassStyleFlags : FT_Long {
#defineDECLARE_FLAG(name) name = FT_STYLE_FLAG_##name
 NORMAL = 0,
DECLARE_FLAG(ITALIC),
DECLARE_FLAG(BOLD),
#undef DECLARE_FLAG
};

P11X_DECLARE_ENUM(
"StyleFlags", "Flag",
 {"NORMAL", StyleFlags::NORMAL},
 {"ITALIC", StyleFlags::ITALIC},
 {"BOLD", StyleFlags::BOLD},
);

/**********************************************************************
 * FT2Image
 * */

constchar *PyFT2Image__doc__ = R"""(
 An image buffer for drawing glyphs.
)""";

constchar *PyFT2Image_init__doc__ = R"""(
 Parameters
 ----------
 width, height : int
 The dimensions of the image buffer.
)""";

constchar *PyFT2Image_draw_rect_filled__doc__ = R"""(
 Draw a filled rectangle to the image.

 Parameters
 ----------
 x0, y0, x1, y1 : float
 The bounds of the rectangle from (x0, y0) to (x1, y1).
)""";

staticvoid
PyFT2Image_draw_rect_filled(FT2Image *self,
 double_or_<long> vx0, double_or_<long> vy0,
 double_or_<long> vx1, double_or_<long> vy1)
{
auto x0 = _double_to_<long>("x0", vx0);
autoy0 = _double_to_<long>("y0", vy0);
auto x1 = _double_to_<long>("x1", vx1);
autoy1 = _double_to_<long>("y1", vy1);

 self->draw_rect_filled(x0, y0, x1, y1);
}

/**********************************************************************
 * Glyph
 * */

typedefstruct
{
size_t glyphInd;
long width;
long height;
long horiBearingX;
long horiBearingY;
long horiAdvance;
long linearHoriAdvance;
long vertBearingX;
long vertBearingY;
long vertAdvance;
 FT_BBox bbox;
} PyGlyph;

constchar *PyGlyph__doc__ = R"""(
 Information about a single glyph.

 You cannot create instances of this object yourself, but must use
 `.FT2Font.load_char` or `.FT2Font.load_glyph` to generate one. This object may be
 used in a call to `.FT2Font.draw_glyph_to_bitmap`.

 For more information on the various metrics, see `the FreeType documentation
 <https://freetype.org/freetype2/docs/glyphs/glyphs-3.html>`_.
)""";

static PyGlyph *
PyGlyph_from_FT2Font(const FT2Font *font)
{
const FT_Face &face = font->get_face();
constlong hinting_factor = font->get_hinting_factor();
const FT_Glyph &glyph = font->get_last_glyph();

 PyGlyph *self = newPyGlyph();

 self->glyphInd = font->get_last_glyph_index();
FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_subpixels, &self->bbox);

 self->width = face->glyph->metrics.width / hinting_factor;
 self->height = face->glyph->metrics.height;
 self->horiBearingX = face->glyph->metrics.horiBearingX / hinting_factor;
 self->horiBearingY = face->glyph->metrics.horiBearingY;
 self->horiAdvance = face->glyph->metrics.horiAdvance;
 self->linearHoriAdvance = face->glyph->linearHoriAdvance / hinting_factor;
 self->vertBearingX = face->glyph->metrics.vertBearingX;
 self->vertBearingY = face->glyph->metrics.vertBearingY;
 self->vertAdvance = face->glyph->metrics.vertAdvance;

return self;
}

static py::tuple
PyGlyph_get_bbox(PyGlyph *self)
{
returnpy::make_tuple(self->bbox.xMin, self->bbox.yMin,
 self->bbox.xMax, self->bbox.yMax);
}

/**********************************************************************
 * FT2Font
 * */

structPyFT2Font
{
 FT2Font *x;
 py::object py_file;
 FT_StreamRec stream;
 py::list fallbacks;

~PyFT2Font()
 {
deletethis->x;
 }
};

constchar *PyFT2Font__doc__ = R"""(
 An object representing a single font face.

 Outside of the font itself and querying its properties, this object provides methods
 for processing text strings into glyph shapes.

 Commonly, one will use `FT2Font.set_text` to load some glyph metrics and outlines.
 Then `FT2Font.draw_glyphs_to_bitmap` and `FT2Font.get_image` may be used to get a
 rendered form of the loaded string.

 For single characters, `FT2Font.load_char` or `FT2Font.load_glyph` may be used,
 either directly for their return values, or to use `FT2Font.draw_glyph_to_bitmap` or
 `FT2Font.get_path`.

 Useful metrics may be examined via the `Glyph` return values or
 `FT2Font.get_kerning`. Most dimensions are given in 26.6 or 16.6 fixed-point
 integers representing subpixels. Divide these values by 64 to produce floating-point
 pixels.
)""";

staticunsignedlong
read_from_file_callback(FT_Stream stream, unsignedlong offset, unsignedchar *buffer,
unsignedlong count)
{
 PyFT2Font *self = (PyFT2Font *)stream->descriptor.pointer;
 Py_ssize_t n_read = 0;
try {
char *tmpbuf;
auto seek_result = self->py_file.attr("seek")(offset);
auto read_result = self->py_file.attr("read")(count);
if (PyBytes_AsStringAndSize(read_result.ptr(), &tmpbuf, &n_read) == -1) {
throwpy::error_already_set();
 }
memcpy(buffer, tmpbuf, n_read);
 } catch (py::error_already_set &eas) {
 eas.discard_as_unraisable(__func__);
if (!count) {
return1; // Non-zero signals error, when count == 0.
 }
 }
return (unsignedlong)n_read;
}

staticvoid
close_file_callback(FT_Stream stream)
{
 PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
 PyFT2Font *self = (PyFT2Font *)stream->descriptor.pointer;
try {
 self->py_file.attr("close")();
 } catch (py::error_already_set &eas) {
 eas.discard_as_unraisable(__func__);
 }
 self->py_file = py::object();
PyErr_Restore(type, value, traceback);
}

staticvoid
ft_glyph_warn(FT_ULong charcode, std::set<FT_String*> family_names)
{
 std::set<FT_String*>::iterator it = family_names.begin();
 std::stringstream ss;
 ss<<*it;
while(++it != family_names.end()){
 ss<<", "<<*it;
 }

auto text_helpers = py::module_::import("matplotlib._text_helpers");
auto warn_on_missing_glyph = text_helpers.attr("warn_on_missing_glyph");
warn_on_missing_glyph(charcode, ss.str());
}

constchar *PyFT2Font_init__doc__ = R"""(
 Parameters
 ----------
 filename : str or file-like
 The source of the font data in a format (ttf or ttc) that FreeType can read.

 hinting_factor : int, optional
 Must be positive. Used to scale the hinting in the x-direction.

 _fallback_list : list of FT2Font, optional
 A list of FT2Font objects used to find missing glyphs.

 .. warning::
 This API is both private and provisional: do not use it directly.

 _kerning_factor : int, optional
 Used to adjust the degree of kerning.

 .. warning::
 This API is private: do not use it directly.
)""";

static PyFT2Font *
PyFT2Font_init(py::object filename, long hinting_factor = 8,
 std::optional<std::vector<PyFT2Font *>> fallback_list = std::nullopt,
int kerning_factor = 0)
{
if (hinting_factor <= 0) {
throwpy::value_error("hinting_factor must be greater than 0");
 }

 PyFT2Font *self = newPyFT2Font();
 self->x = nullptr;
memset(&self->stream, 0, sizeof(FT_StreamRec));
 self->stream.base = nullptr;
 self->stream.size = 0x7fffffff; // Unknown size.
 self->stream.pos = 0;
 self->stream.descriptor.pointer = self;
 self->stream.read = &read_from_file_callback;
 FT_Open_Args open_args;
memset((void *)&open_args, 0, sizeof(FT_Open_Args));
 open_args.flags = FT_OPEN_STREAM;
 open_args.stream = &self->stream;

 std::vector<FT2Font *> fallback_fonts;
if (fallback_list) {
// go through fallbacks to add them to our lists
for (auto item : *fallback_list) {
 self->fallbacks.append(item);
// Also (locally) cache the underlying FT2Font objects. As long as
// the Python objects are kept alive, these pointer are good.
 FT2Font *fback = item->x;
 fallback_fonts.push_back(fback);
 }
 }

if (py::isinstance<py::bytes>(filename) || py::isinstance<py::str>(filename)) {
 self->py_file = py::module_::import("io").attr("open")(filename, "rb");
 self->stream.close = &close_file_callback;
 } else {
try {
// This will catch various issues:
// 1. `read` not being an attribute.
// 2. `read` raising an error.
// 3. `read` returning something other than `bytes`.
auto data = filename.attr("read")(0).cast<py::bytes>();
 } catch (const std::exception&) {
throwpy::type_error(
"First argument must be a path to a font file or a binary-mode file object");
 }
 self->py_file = filename;
 self->stream.close = nullptr;
 }

 self->x = newFT2Font(open_args, hinting_factor, fallback_fonts, ft_glyph_warn);

 self->x->set_kerning_factor(kerning_factor);

return self;
}

constchar *PyFT2Font_clear__doc__ =
"Clear all the glyphs, reset for a new call to `.set_text`.";

staticvoid
PyFT2Font_clear(PyFT2Font *self)
{
 self->x->clear();
}

constchar *PyFT2Font_set_size__doc__ = R"""(
 Set the size of the text.

 Parameters
 ----------
 ptsize : float
 The size of the text in points.
 dpi : float
 The DPI used for rendering the text.
)""";

staticvoid
PyFT2Font_set_size(PyFT2Font *self, double ptsize, double dpi)
{
 self->x->set_size(ptsize, dpi);
}

constchar *PyFT2Font_set_charmap__doc__ = R"""(
 Make the i-th charmap current.

 For more details on character mapping, see the `FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-character_mapping.html>`_.

 Parameters
 ----------
 i : int
 The charmap number in the range [0, `.num_charmaps`).

 See Also
 --------
 .num_charmaps
 .select_charmap
 .get_charmap
)""";

staticvoid
PyFT2Font_set_charmap(PyFT2Font *self, int i)
{
 self->x->set_charmap(i);
}

constchar *PyFT2Font_select_charmap__doc__ = R"""(
 Select a charmap by its FT_Encoding number.

 For more details on character mapping, see the `FreeType documentation
 <https://freetype.org/freetype2/docs/reference/ft2-character_mapping.html>`_.

 Parameters
 ----------
 i : int
 The charmap in the form defined by FreeType:
 https://freetype.org/freetype2/docs/reference/ft2-character_mapping.html#ft_encoding

 See Also
 --------
 .set_charmap
 .get_charmap
)""";

staticvoid
PyFT2Font_select_charmap(PyFT2Font *self, unsignedlong i)
{
 self->x->select_charmap(i);
}

constchar *PyFT2Font_get_kerning__doc__ = R"""(
 Get the kerning between two glyphs.

 Parameters
 ----------
 left, right : int
 The glyph indices. Note these are not characters nor character codes.
 Use `.get_char_index` to convert character codes to glyph indices.

 mode : Kerning
 A kerning mode constant:

 - ``DEFAULT`` - Return scaled and grid-fitted kerning distances.
 - ``UNFITTED`` - Return scaled but un-grid-fitted kerning distances.
 - ``UNSCALED`` - Return the kerning vector in original font units.

 .. versionchanged:: 3.10
 This now takes a `.ft2font.Kerning` value instead of an `int`.

 Returns
 -------
 int
 The kerning adjustment between the two glyphs.
)""";

staticint
PyFT2Font_get_kerning(PyFT2Font *self, FT_UInt left, FT_UInt right,
 std::variant<FT_Kerning_Mode, FT_UInt> mode_or_int)
{
bool fallback = true;
 FT_Kerning_Mode mode;

if (auto value = std::get_if<FT_UInt>(&mode_or_int)) {
auto api = py::module_::import("matplotlib._api");
auto warn = api.attr("warn_deprecated");
warn("since"_a="3.10", "name"_a="mode", "obj_type"_a="parameter as int",
"alternative"_a="Kerning enum values");
 mode = static_cast<FT_Kerning_Mode>(*value);
 } elseif (auto value = std::get_if<FT_Kerning_Mode>(&mode_or_int)) {
 mode = *value;
 } else {
// NOTE: this can never happen as pybind11 would have checked the type in the
// Python wrapper before calling this function, but we need to keep the
// std::get_if instead of std::get for macOS 10.12 compatibility.
throwpy::type_error("mode must be Kerning or int");
 }

return self->x->get_kerning(left, right, mode, fallback);
}

constchar *PyFT2Font_get_fontmap__doc__ = R"""(
 Get a mapping between characters and the font that includes them.

 .. warning::
 This API uses the fallback list and is both private and provisional: do not use
 it directly.

 Parameters
 ----------
 text : str
 The characters for which to find fonts.

 Returns
 -------
 dict[str, FT2Font]
 A dictionary mapping unicode characters to `.FT2Font` objects.
)""";

static py::dict
PyFT2Font_get_fontmap(PyFT2Font *self, std::u32string text)
{
 std::set<FT_ULong> codepoints;

 py::dict char_to_font;
for (auto code : text) {
if (!codepoints.insert(code).second) {
continue;
 }

 py::object target_font;
intindex;
if (self->x->get_char_fallback_index(code, index)) {
if (index >= 0) {
 target_font = self->fallbacks[index];
 } else {
 target_font = py::cast(self);
 }
 } else {
// TODO Handle recursion!
 target_font = py::cast(self);
 }

auto key = py::cast(std::u32string(1, code));
 char_to_font[key] = target_font;
 }
return char_to_font;
}

constchar *PyFT2Font_set_text__doc__ = R"""(
 Set the text *string* and *angle*.

 You must call this before `.draw_glyphs_to_bitmap`.

 Parameters
 ----------
 string : str
 The text to prepare rendering information for.
 angle : float
 The angle at which to render the supplied text.
 flags : LoadFlags, default: `.LoadFlags.FORCE_AUTOHINT`
 Any bitwise-OR combination of the `.LoadFlags` flags.

 .. versionchanged:: 3.10
 This now takes an `.ft2font.LoadFlags` instead of an int.

 Returns
 -------
 np.ndarray[double]
 A sequence of x,y glyph positions in 26.6 subpixels; divide by 64 for pixels.
)""";

static py::array_t<double>
PyFT2Font_set_text(PyFT2Font *self, std::u32string_view text, double angle = 0.0,
 std::variant<LoadFlags, FT_Int32> flags_or_int = LoadFlags::FORCE_AUTOHINT)
{
 std::vector<double> xys;
 LoadFlags flags;

if (auto value = std::get_if<FT_Int32>(&flags_or_int)) {
auto api = py::module_::import("matplotlib._api");
auto warn = api.attr("warn_deprecated");
warn("since"_a="3.10", "name"_a="flags", "obj_type"_a="parameter as int",
"alternative"_a="LoadFlags enum values");
 flags = static_cast<LoadFlags>(*value);
 } elseif (auto value = std::get_if<LoadFlags>(&flags_or_int)) {
 flags = *value;
 } else {
// NOTE: this can never happen as pybind11 would have checked the type in the
// Python wrapper before calling this function, but we need to keep the
// std::get_if instead of std::get for macOS 10.12 compatibility.
throwpy::type_error("flags must be LoadFlags or int");
 }

 self->x->set_text(text, angle, static_cast<FT_Int32>(flags), xys);

 py::ssize_t dims[] = { static_cast<py::ssize_t>(xys.size()) / 2, 2 };
 py::array_t<double> result(dims);
if (xys.size() > 0) {
memcpy(result.mutable_data(), xys.data(), result.nbytes());
 }
return result;
}

constchar *PyFT2Font_get_num_glyphs__doc__ = "Return the number of loaded glyphs.";

staticsize_t
PyFT2Font_get_num_glyphs(PyFT2Font *self)
{
return self->x->get_num_glyphs();
}

constchar *PyFT2Font_load_char__doc__ = R"""(
 Load character in current fontfile and set glyph.

 Parameters
 ----------
 charcode : int
 The character code to prepare rendering information for. This code must be in
 the charmap, or else a ``.notdef`` glyph may be returned instead.
 flags : LoadFlags, default: `.LoadFlags.FORCE_AUTOHINT`
 Any bitwise-OR combination of the `.LoadFlags` flags.

 .. versionchanged:: 3.10
 This now takes an `.ft2font.LoadFlags` instead of an int.

 Returns
 -------
 Glyph
 The glyph information corresponding to the specified character.

 See Also
 --------
 .load_glyph
 .select_charmap
 .set_charmap
)""";

static PyGlyph *
PyFT2Font_load_char(PyFT2Font *self, long charcode,
 std::variant<LoadFlags, FT_Int32> flags_or_int = LoadFlags::FORCE_AUTOHINT)
{
bool fallback = true;
 FT2Font *ft_object = nullptr;
 LoadFlags flags;

if (auto value = std::get_if<FT_Int32>(&flags_or_int)) {
auto api = py::module_::import("matplotlib._api");
auto warn = api.attr("warn_deprecated");
warn("since"_a="3.10", "name"_a="flags", "obj_type"_a="parameter as int",
"alternative"_a="LoadFlags enum values");
 flags = static_cast<LoadFlags>(*value);
 } elseif (auto value = std::get_if<LoadFlags>(&flags_or_int)) {
 flags = *value;
 } else {
// NOTE: this can never happen as pybind11 would have checked the type in the
// Python wrapper before calling this function, but we need to keep the
// std::get_if instead of std::get for macOS 10.12 compatibility.
throwpy::type_error("flags must be LoadFlags or int");
 }

 self->x->load_char(charcode, static_cast<FT_Int32>(flags), ft_object, fallback);

returnPyGlyph_from_FT2Font(ft_object);
}

constchar *PyFT2Font_load_glyph__doc__ = R"""(
 Load glyph index in current fontfile and set glyph.

 Note that the glyph index is specific to a font, and not universal like a Unicode
 code point.

 Parameters
 ----------
 glyph_index : int
 The glyph index to prepare rendering information for.
 flags : LoadFlags, default: `.LoadFlags.FORCE_AUTOHINT`
 Any bitwise-OR combination of the `.LoadFlags` flags.

 .. versionchanged:: 3.10
 This now takes an `.ft2font.LoadFlags` instead of an int.

 Returns
 -------
 Glyph
 The glyph information corresponding to the specified index.

 See Also
 --------
 .load_char
)""";

static PyGlyph *
PyFT2Font_load_glyph(PyFT2Font *self, FT_UInt glyph_index,
 std::variant<LoadFlags, FT_Int32> flags_or_int = LoadFlags::FORCE_AUTOHINT)
{
bool fallback = true;
 FT2Font *ft_object = nullptr;
 LoadFlags flags;

if (auto value = std::get_if<FT_Int32>(&flags_or_int)) {
auto api = py::module_::import("matplotlib._api");
auto warn = api.attr("warn_deprecated");
warn("since"_a="3.10", "name"_a="flags", "obj_type"_a="parameter as int",
"alternative"_a="LoadFlags enum values");
 flags = static_cast<LoadFlags>(*value);
 } elseif (auto value = std::get_if<LoadFlags>(&flags_or_int)) {
 flags = *value;
 } else {
// NOTE: this can never happen as pybind11 would have checked the type in the
// Python wrapper before calling this function, but we need to keep the
// std::get_if instead of std::get for macOS 10.12 compatibility.
throwpy::type_error("flags must be LoadFlags or int");
 }

 self->x->load_glyph(glyph_index, static_cast<FT_Int32>(flags), ft_object, fallback);

returnPyGlyph_from_FT2Font(ft_object);
}

constchar *PyFT2Font_get_width_height__doc__ = R"""(
 Get the dimensions of the current string set by `.set_text`.

 The rotation of the string is accounted for.

 Returns
 -------
 width, height : float
 The width and height in 26.6 subpixels of the current string. To get width and
 height in pixels, divide these values by 64.

 See Also
 --------
 .get_bitmap_offset
 .get_descent
)""";

static py::tuple
PyFT2Font_get_width_height(PyFT2Font *self)
{
long width, height;

 self->x->get_width_height(&width, &height);

returnpy::make_tuple(width, height);
}

constchar *PyFT2Font_get_bitmap_offset__doc__ = R"""(
 Get the (x, y) offset for the bitmap if ink hangs left or below (0, 0).

 Since Matplotlib only supports left-to-right text, y is always 0.

 Returns
 -------
 x, y : float
 The x and y offset in 26.6 subpixels of the bitmap. To get x and y in pixels,
 divide these values by 64.

 See Also
 --------
 .get_width_height
 .get_descent
)""";

static py::tuple
PyFT2Font_get_bitmap_offset(PyFT2Font *self)
{
long x, y;

 self->x->get_bitmap_offset(&x, &y);

returnpy::make_tuple(x, y);
}

constchar *PyFT2Font_get_descent__doc__ = R"""(
 Get the descent of the current string set by `.set_text`.

 The rotation of the string is accounted for.

 Returns
 -------
 int
 The descent in 26.6 subpixels of the bitmap. To get the descent in pixels,
 divide these values by 64.

 See Also
 --------
 .get_bitmap_offset
 .get_width_height
)""";

staticlong
PyFT2Font_get_descent(PyFT2Font *self)
{
return self->x->get_descent();
}

constchar *PyFT2Font_draw_glyphs_to_bitmap__doc__ = R"""(
 Draw the glyphs that were loaded by `.set_text` to the bitmap.

 The bitmap size will be automatically set to include the glyphs.

 Parameters
 ----------
 antialiased : bool, default: True
 Whether to render glyphs 8-bit antialiased or in pure black-and-white.

 See Also
 --------
 .draw_glyph_to_bitmap
)""";

staticvoid
PyFT2Font_draw_glyphs_to_bitmap(PyFT2Font *self, bool antialiased = true)
{
 self->x->draw_glyphs_to_bitmap(antialiased);
}

constchar *PyFT2Font_draw_glyph_to_bitmap__doc__ = R"""(
 Draw a single glyph to the bitmap at pixel locations x, y.

 Note it is your responsibility to create the image manually with the correct size
 before this call is made.

 If you want automatic layout, use `.set_text` in combinations with
 `.draw_glyphs_to_bitmap`. This function is instead intended for people who want to
 render individual glyphs (e.g., returned by `.load_char`) at precise locations.

 Parameters
 ----------
 image : FT2Image
 The image buffer on which to draw the glyph.
 x, y : int
 The pixel location at which to draw the glyph.
 glyph : Glyph
 The glyph to draw.
 antialiased : bool, default: True
 Whether to render glyphs 8-bit antialiased or in pure black-and-white.

 See Also
 --------
 .draw_glyphs_to_bitmap
)""";

staticvoid
PyFT2Font_draw_glyph_to_bitmap(PyFT2Font *self, FT2Image &image,
 double_or_<int> vxd, double_or_<int> vyd,
 PyGlyph *glyph, bool antialiased = true)
{
auto xd = _double_to_<int>("x", vxd);
auto yd = _double_to_<int>("y", vyd);

 self->x->draw_glyph_to_bitmap(image, xd, yd, glyph->glyphInd, antialiased);
}

constchar *PyFT2Font_get_glyph_name__doc__ = R"""(
 Retrieve the ASCII name of a given glyph *index* in a face.

 Due to Matplotlib's internal design, for fonts that do not contain glyph names (per
 ``FT_FACE_FLAG_GLYPH_NAMES``), this returns a made-up name which does *not*
 roundtrip through `.get_name_index`.

 Parameters
 ----------
 index : int
 The glyph number to query.

 Returns
 -------
 str
 The name of the glyph, or if the font does not contain names, a name synthesized
 by Matplotlib.

 See Also
 --------
 .get_name_index
)""";