#define NPY_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>

namespace py = pybind11;

using namespace pybind11::literals;

template <typename T>

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

template <typename T>

static T

_double_to_(const char *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));

return static_cast<T>(*value);

} else if (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.

throw std::runtime_error("Should not happen");

}

}

/**********************************************************************

* Enumerations

* */

const char *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},

);

const char *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.

#define FT_FACE_FLAG_VARIATION (1L << 15)

#endif

#ifndef FT_FACE_FLAG_SVG // backcompat: ft 2.12.0.

#define FT_FACE_FLAG_SVG (1L << 16)

#endif

#ifndef FT_FACE_FLAG_SBIX // backcompat: ft 2.12.0.

#define FT_FACE_FLAG_SBIX (1L << 17)

#endif

#ifndef FT_FACE_FLAG_SBIX_OVERLAY // backcompat: ft 2.12.0.

#define FT_FACE_FLAG_SBIX_OVERLAY (1L << 18)

#endif

enum class FaceFlags : FT_Long {

#define DECLARE_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},

);

const char *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.

#define FT_LOAD_COMPUTE_METRICS (1L << 21)

#endif

#ifndef FT_LOAD_BITMAP_METRICS_ONLY // backcompat: ft 2.7.1.

#define FT_LOAD_BITMAP_METRICS_ONLY (1L << 22)

#endif

#ifndef FT_LOAD_NO_SVG // backcompat: ft 2.13.1.

#define FT_LOAD_NO_SVG (1L << 24)

#endif

enum class LoadFlags : FT_Int32 {

#define DECLARE_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},

);

const char *RenderMode__doc__ = R"""(

Render modes.

For more information, see `the FreeType documentation

<https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_render_mode>`_.

.. versionadded:: 3.10

)""";

P11X_DECLARE_ENUM(

"RenderMode", "Enum",

{"NORMAL", FT_RENDER_MODE_NORMAL},

{"LIGHT", FT_RENDER_MODE_LIGHT},

{"MONO", FT_RENDER_MODE_MONO},

{"LCD", FT_RENDER_MODE_LCD},

{"LCD_V", FT_RENDER_MODE_LCD_V},

{"SDF", FT_RENDER_MODE_SDF},

);

const char *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

)""";

enum class StyleFlags : FT_Long {

#define DECLARE_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

* */

const char *PyFT2Image__doc__ = R"""(

An image buffer for drawing glyphs.

)""";

const char *PyFT2Image_init__doc__ = R"""(

Parameters

----------

width, height : int

The dimensions of the image buffer.

)""";

const char *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).

)""";

static void

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);

auto y0 = _double_to_<long>("y0", vy0);

auto x1 = _double_to_<long>("x1", vx1);

auto y1 = _double_to_<long>("y1", vy1);

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

}

/**********************************************************************

* Positioned Bitmap; owns the FT_Bitmap!

* */

struct PyPositionedBitmap {

FT_Int left, top;

bool owning;

FT_Bitmap bitmap;

PyPositionedBitmap(FT_GlyphSlot slot) :

left{slot->bitmap_left}, top{slot->bitmap_top}, owning{true}

{

FT_Bitmap_Init(&bitmap);

FT_CHECK(FT_Bitmap_Convert, _ft2Library, &slot->bitmap, &bitmap, 1);

}

PyPositionedBitmap(FT_BitmapGlyph bg) :

left{bg->left}, top{bg->top}, owning{true}

{

FT_Bitmap_Init(&bitmap);

FT_CHECK(FT_Bitmap_Convert, _ft2Library, &bg->bitmap, &bitmap, 1);

}

PyPositionedBitmap(PyPositionedBitmap& other) = delete; // Non-copyable.

PyPositionedBitmap(PyPositionedBitmap&& other) :

left{other.left}, top{other.top}, owning{true}, bitmap{other.bitmap}

{

other.owning = false; // Prevent double deletion.

}

~PyPositionedBitmap()

{

if (owning) {

FT_Bitmap_Done(_ft2Library, &bitmap);

}

}

};

/**********************************************************************

* Glyph

* */

typedef struct

{

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;

const char *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();

const FT_Glyph &glyph = font->get_last_glyph();

PyGlyph *self = new PyGlyph();

self->glyphInd = font->get_last_glyph_index();

FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_subpixels, &self->bbox);

self->width = face->glyph->metrics.width;

self->height = face->glyph->metrics.height;

self->horiBearingX = face->glyph->metrics.horiBearingX;

self->horiBearingY = face->glyph->metrics.horiBearingY;

self->horiAdvance = face->glyph->metrics.horiAdvance;

self->linearHoriAdvance = face->glyph->linearHoriAdvance;

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)

{

return py::make_tuple(self->bbox.xMin, self->bbox.yMin,

self->bbox.xMax, self->bbox.yMax);

}

/**********************************************************************

* FT2Font

* */

class PyFT2Font final : public FT2Font

{

public:

using FT2Font::FT2Font;

py::object py_file;

FT_StreamRec stream;

py::list fallbacks;

~PyFT2Font()

{

// Because destructors are called from subclass up to base class, we need to

// explicitly close the font here. Otherwise, the instance attributes here will

// be destroyed before the font itself, but those are used in the close callback.

close();

}

void 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());

}

};

const char *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.

)""";

static unsigned long

read_from_file_callback(FT_Stream stream, unsigned long offset, unsigned char *buffer,

unsigned long 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) {

throw py::error_already_set();

}

memcpy(buffer, tmpbuf, n_read);

} catch (py::error_already_set &eas) {

eas.discard_as_unraisable(__func__);

if (!count) {

return 1; // Non-zero signals error, when count == 0.

}

}

return (unsigned long)n_read;

}

static void

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);

}

const char *PyFT2Font_init__doc__ = R"""(

Parameters

----------

filename : str, bytes, os.PathLike, or io.BinaryIO

The source of the font data in a format (ttf or ttc) that FreeType can read.

face_index : int, optional

The index of the face in the font file to load.

_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.

_warn_if_used : bool, optional

Used to trigger missing glyph warnings.

.. warning::

This API is private: do not use it directly.

)""";

static PyFT2Font *

PyFT2Font_init(py::object filename, std::optional<long> hinting_factor = std::nullopt,

FT_Long face_index = 0,

std::optional<std::vector<PyFT2Font *>> fallback_list = std::nullopt,

std::optional<int> kerning_factor = std::nullopt,

bool warn_if_used = false)

{

if (hinting_factor) {

auto api = py::module_::import("matplotlib._api");

auto warn = api.attr("warn_deprecated");

warn("since"_a="3.11", "name"_a="hinting_factor", "obj_type"_a="parameter");

}

if (kerning_factor) {

auto api = py::module_::import("matplotlib._api");

auto warn = api.attr("warn_deprecated");

warn("since"_a="3.11", "name"_a="_kerning_factor", "obj_type"_a="parameter");

} else {

kerning_factor = 0;

}

if (face_index < 0 || face_index > 0xffff) {

throw std::range_error("face_index must be between 0 and 65535, inclusive");

}

std::vector<FT2Font *> fallback_fonts;

if (fallback_list) {

// go through fallbacks to add them to our lists

std::copy(fallback_list->begin(), fallback_list->end(),

std::back_inserter(fallback_fonts));

}

auto self = new PyFT2Font(fallback_fonts, warn_if_used);

self->set_kerning_factor(*kerning_factor);

if (fallback_list) {

// go through fallbacks to add them to our lists

for (auto item : *fallback_list) {

self->fallbacks.append(item);

}

}

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;

auto PathLike = py::module_::import("os").attr("PathLike");

if (py::isinstance<py::bytes>(filename) || py::isinstance<py::str>(filename) ||

py::isinstance(filename, PathLike))

{

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&) {

throw py::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->open(open_args, face_index);

return self;

}

static py::object

PyFT2Font_fname(PyFT2Font *self)

{

if (self->stream.close) { // User passed a filename to the constructor.

return self->py_file.attr("name");

} else {

return self->py_file;

}

}

const char *PyFT2Font_clear__doc__ =

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

const char *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.

)""";

const char *PyFT2Font__set_transform__doc__ = R"""(

Set the transform of the text.

This is a low-level function, where *matrix* and *delta* are directly in

16.16 and 26.6 formats respectively. Refer to the FreeType docs of

FT_Set_Transform for further description.

Note, every call to `.font_manager.get_font` will reset the transform to the default

to ensure consistency across cache accesses.

Parameters

----------

matrix : (2, 2) array of int

delta : (2,) array of int

)""";

const char *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

)""";

const char *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

)""";

const char *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.

)""";

static int

PyFT2Font_get_kerning(PyFT2Font *self, FT_UInt left, FT_UInt right,

std::variant<FT_Kerning_Mode, FT_UInt> mode_or_int)

{

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);

} else if (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.

throw py::type_error("mode must be Kerning or int");

}

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

}

const char *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.

features : tuple[str, ...]

The font feature tags to use for the font.

Available font feature tags may be found at

https://learn.microsoft.com/en-us/typography/opentype/spec/featurelist

.. versionadded:: 3.11

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::optional<std::vector<std::string>> features = std::nullopt,

std::variant<FT2Font::LanguageType, std::string> languages_or_str = nullptr)

{

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);

} else if (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.

throw py::type_error("flags must be LoadFlags or int");

}

FT2Font::LanguageType languages;

if (auto value = std::get_if<FT2Font::LanguageType>(&languages_or_str)) {

languages = std::move(*value);

} else if (auto value = std::get_if<std::string>(&languages_or_str)) {

languages = std::vector<FT2Font::LanguageRange>{

FT2Font::LanguageRange{*value, 0, text.size()}

};

} 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.

throw py::type_error("languages must be str or list of tuple");

}

self->set_text(text, angle, static_cast<FT_Int32>(flags), features, languages, 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;

}

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

const char *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);

} else if (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.

throw py::type_error("flags must be LoadFlags or int");

}

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

return PyGlyph_from_FT2Font(ft_object);

}

const char *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)

{

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);

} else if (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.

throw py::type_error("flags must be LoadFlags or int");

}

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

return PyGlyph_from_FT2Font(self);

}

const char *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

)""";

const char *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

)""";

const char *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

)""";

const char *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

)""";

const char *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 : 2d array of uint8

The image buffer on which to draw the glyph.

x, y : int

The position of the glyph's top left corner.

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

)""";

static void

PyFT2Font_draw_glyph_to_bitmap(PyFT2Font *self, py::buffer &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->draw_glyph_to_bitmap(

py::array_t<uint8_t, py::array::c_style>{image},

xd, yd, glyph->glyphInd, antialiased);

}

const char *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