{

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

}

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

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

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

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

}

}

{

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

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

{

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

}

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;

{

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

{

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

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

} else {

return self->py_file;

}

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

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;

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