#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<double, T>;

template <typename T>

static T

_double_to_(const char *name, double_or_<T> &var)

}

const char *Kerning__doc__ = R"""(

)""";

P11X_DECLARE_ENUM(

"Kerning", "Enum",

{"DEFAULT", FT_KERNING_DEFAULT},

{"UNFITTED", FT_KERNING_UNFITTED},

{"UNSCALED", FT_KERNING_UNSCALED},

);

const char *FaceFlags__doc__ = R"""(

)""";

#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),

};

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"""(

)""";

#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),

};

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 *StyleFlags__doc__ = R"""(

)""";

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

);

const char *PyFT2Image__doc__ = R"""(

)""";

const char *PyFT2Image_init__doc__ = R"""(

)""";

const char *PyFT2Image_draw_rect_filled__doc__ = R"""(

)""";

static void

PyFT2Image_draw_rect_filled(FT2Image *self,

}

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"""(

)""";

static PyGlyph *

PyGlyph_from_FT2Font(const FT2Font *font)

{

const FT_Face &face = font->get_face();

const long hinting_factor = font->get_hinting_factor();

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

}

struct PyFT2Font

};

const char *PyFT2Font__doc__ = R"""(

)""";

static unsigned long

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

}

static void

close_file_callback(FT_Stream stream)

}

static void

ft_glyph_warn(FT_ULong charcode, std::set<FT_String*> family_names)

}

const char *PyFT2Font_init__doc__ = R"""(

)""";

static PyFT2Font *

PyFT2Font_init(py::object filename, long hinting_factor = 8,

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

int kerning_factor = 0, bool warn_if_used = false)

{

if (hinting_factor <= 0) {

throw py::value_error("hinting_factor must be greater than 0");

}

PyFT2Font *self = new PyFT2Font();

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

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->x = new FT2Font(open_args, hinting_factor, fallback_fonts, ft_glyph_warn,

warn_if_used);

self->x->set_kerning_factor(kerning_factor);

return self;

}

static py::str

PyFT2Font_fname(PyFT2Font *self)

}

const char *PyFT2Font_clear__doc__ =

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

static void

PyFT2Font_clear(PyFT2Font *self)

{

self->x->clear();

}

const char *PyFT2Font_set_size__doc__ = R"""(

)""";

static void

PyFT2Font_set_size(PyFT2Font *self, double ptsize, double dpi)

{

self->x->set_size(ptsize, dpi);

}

const char *PyFT2Font_set_charmap__doc__ = R"""(

)""";

static void

PyFT2Font_set_charmap(PyFT2Font *self, int i)

{

self->x->set_charmap(i);

}

const char *PyFT2Font_select_charmap__doc__ = R"""(

)""";

static void

PyFT2Font_select_charmap(PyFT2Font *self, unsigned long i)

{

self->x->select_charmap(i);

}

const char *PyFT2Font_get_kerning__doc__ = R"""(

)""";

static int

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

}

const char *PyFT2Font_get_fontmap__doc__ = R"""(

)""";

static py::dict

PyFT2Font_get_fontmap(PyFT2Font *self, std::u32string text)

}

const char *PyFT2Font_set_text__doc__ = R"""(

)""";

static py::array_t<double>

PyFT2Font_set_text(PyFT2Font *self, std::u32string_view text, double angle = 0.0,

}

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

static size_t

PyFT2Font_get_num_glyphs(PyFT2Font *self)

{

return self->x->get_num_glyphs();

}

const char *PyFT2Font_load_char__doc__ = R"""(

)""";

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->x->load_char(charcode, static_cast<FT_Int32>(flags), ft_object, fallback);

return PyGlyph_from_FT2Font(ft_object);

}

const char *PyFT2Font_load_glyph__doc__ = R"""(

)""";

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

} 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->x->load_glyph(glyph_index, static_cast<FT_Int32>(flags), ft_object, fallback);

return PyGlyph_from_FT2Font(ft_object);

}

const char *PyFT2Font_get_width_height__doc__ = R"""(

)""";

static py::tuple

PyFT2Font_get_width_height(PyFT2Font *self)

}

const char *PyFT2Font_get_bitmap_offset__doc__ = R"""(

)""";

static py::tuple

PyFT2Font_get_bitmap_offset(PyFT2Font *self)

}

const char *PyFT2Font_get_descent__doc__ = R"""(

)""";

static long

PyFT2Font_get_descent(PyFT2Font *self)

{

return self->x->get_descent();

}

const char *PyFT2Font_draw_glyphs_to_bitmap__doc__ = R"""(

)""";

static void

PyFT2Font_draw_glyphs_to_bitmap(PyFT2Font *self, bool antialiased = true)

{

self->x->draw_glyphs_to_bitmap(antialiased);

}

const char *PyFT2Font_draw_glyph_to_bitmap__doc__ = R"""(

)""";

static void

PyFT2Font_draw_glyph_to_bitmap(PyFT2Font *self, py::buffer &image,

}

const char *PyFT2Font_get_glyph_name__doc__ = R"""(