#include "mplutils.h"

#include "ft2font.h"

#include "py_converters.h"

#include "py_exceptions.h"

#include "numpy_cpp.h"

#include <structmember.h>

#include <set>

#include <algorithm>

#define STRINGIFY(s) XSTRINGIFY(s)

#define XSTRINGIFY(s) #s

static PyObject *convert_xys_to_array(std::vector<double> &xys)

{

npy_intp dims[] = {(npy_intp)xys.size() / 2, 2 };

if (dims[0] > 0) {

return PyArray_SimpleNewFromData(2, dims, NPY_DOUBLE, &xys[0]);

} else {

return PyArray_SimpleNew(2, dims, NPY_DOUBLE);

}

}

typedef struct

{

PyObject_HEAD

FT2Image *x;

Py_ssize_t shape[2];

Py_ssize_t strides[2];

Py_ssize_t suboffsets[2];

} PyFT2Image;

static PyTypeObject PyFT2ImageType;

static PyObject *PyFT2Image_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyFT2Image *self;

self = (PyFT2Image *)type->tp_alloc(type, 0);

self->x = NULL;

return (PyObject *)self;

}

static int PyFT2Image_init(PyFT2Image *self, PyObject *args, PyObject *kwds)

}

static void PyFT2Image_dealloc(PyFT2Image *self)

}

const char *PyFT2Image_draw_rect__doc__ =

"draw_rect(self, x0, y0, x1, y1)\n"

"--\n\n"

"Draw an empty rectangle to the image.\n";

static PyObject *PyFT2Image_draw_rect(PyFT2Image *self, PyObject *args)

{

double x0, y0, x1, y1;

if (!PyArg_ParseTuple(args, "dddd:draw_rect", &x0, &y0, &x1, &y1)) {

return NULL;

}

CALL_CPP("draw_rect", (self->x->draw_rect(x0, y0, x1, y1)));

Py_RETURN_NONE;

}

const char *PyFT2Image_draw_rect_filled__doc__ =

"draw_rect_filled(self, x0, y0, x1, y1)\n"

"--\n\n"

"Draw a filled rectangle to the image.\n";

static PyObject *PyFT2Image_draw_rect_filled(PyFT2Image *self, PyObject *args)

{

double x0, y0, x1, y1;

if (!PyArg_ParseTuple(args, "dddd:draw_rect_filled", &x0, &y0, &x1, &y1)) {

return NULL;

}

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

Py_RETURN_NONE;

}

static int PyFT2Image_get_buffer(PyFT2Image *self, Py_buffer *buf, int flags)

}

static PyTypeObject* PyFT2Image_init_type()

{

static PyMethodDef methods[] = {

{"draw_rect", (PyCFunction)PyFT2Image_draw_rect, METH_VARARGS, PyFT2Image_draw_rect__doc__},

{"draw_rect_filled", (PyCFunction)PyFT2Image_draw_rect_filled, METH_VARARGS, PyFT2Image_draw_rect_filled__doc__},

{NULL}

};

static PyBufferProcs buffer_procs;

buffer_procs.bf_getbuffer = (getbufferproc)PyFT2Image_get_buffer;

PyFT2ImageType.tp_name = "matplotlib.ft2font.FT2Image";

PyFT2ImageType.tp_basicsize = sizeof(PyFT2Image);

PyFT2ImageType.tp_dealloc = (destructor)PyFT2Image_dealloc;

PyFT2ImageType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

PyFT2ImageType.tp_methods = methods;

PyFT2ImageType.tp_new = PyFT2Image_new;

PyFT2ImageType.tp_init = (initproc)PyFT2Image_init;

PyFT2ImageType.tp_as_buffer = &buffer_procs;

return &PyFT2ImageType;

}

typedef struct

{

PyObject_HEAD

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;

static PyTypeObject PyGlyphType;

static PyObject *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;

self = (PyGlyph *)PyGlyphType.tp_alloc(&PyGlyphType, 0);

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 (PyObject *)self;

}

static void PyGlyph_dealloc(PyGlyph *self)

{

Py_TYPE(self)->tp_free((PyObject *)self);

}

static PyObject *PyGlyph_get_bbox(PyGlyph *self, void *closure)

{

return Py_BuildValue(

"llll", self->bbox.xMin, self->bbox.yMin, self->bbox.xMax, self->bbox.yMax);

}

static PyTypeObject *PyGlyph_init_type()

{

static PyMemberDef members[] = {

{(char *)"width", T_LONG, offsetof(PyGlyph, width), READONLY, (char *)""},

{(char *)"height", T_LONG, offsetof(PyGlyph, height), READONLY, (char *)""},

{(char *)"horiBearingX", T_LONG, offsetof(PyGlyph, horiBearingX), READONLY, (char *)""},

{(char *)"horiBearingY", T_LONG, offsetof(PyGlyph, horiBearingY), READONLY, (char *)""},

{(char *)"horiAdvance", T_LONG, offsetof(PyGlyph, horiAdvance), READONLY, (char *)""},

{(char *)"linearHoriAdvance", T_LONG, offsetof(PyGlyph, linearHoriAdvance), READONLY, (char *)""},

{(char *)"vertBearingX", T_LONG, offsetof(PyGlyph, vertBearingX), READONLY, (char *)""},

{(char *)"vertBearingY", T_LONG, offsetof(PyGlyph, vertBearingY), READONLY, (char *)""},

{(char *)"vertAdvance", T_LONG, offsetof(PyGlyph, vertAdvance), READONLY, (char *)""},

{NULL}

};

static PyGetSetDef getset[] = {

{(char *)"bbox", (getter)PyGlyph_get_bbox, NULL, NULL, NULL},

{NULL}

};

PyGlyphType.tp_name = "matplotlib.ft2font.Glyph";

PyGlyphType.tp_basicsize = sizeof(PyGlyph);

PyGlyphType.tp_dealloc = (destructor)PyGlyph_dealloc;

PyGlyphType.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

PyGlyphType.tp_members = members;

PyGlyphType.tp_getset = getset;

return &PyGlyphType;

}

struct PyFT2Font

};

static PyTypeObject PyFT2FontType;

static unsigned long read_from_file_callback(FT_Stream stream,

}

static void close_file_callback(FT_Stream stream)

}

static PyObject *PyFT2Font_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

PyFT2Font *self;

self = (PyFT2Font *)type->tp_alloc(type, 0);

self->x = NULL;

self->py_file = NULL;

memset(&self->stream, 0, sizeof(FT_StreamRec));

return (PyObject *)self;

}

const char *PyFT2Font_init__doc__ =

"FT2Font(filename, hinting_factor=8, *, _fallback_list=None, _kerning_factor=0)\n"

"--\n\n"

"Create a new FT2Font object.\n"

"\n"

"Parameters\n"

"----------\n"

"filename : str or file-like\n"

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

"hinting_factor : int, optional\n"

" Must be positive. Used to scale the hinting in the x-direction\n"

"_fallback_list : list of FT2Font, optional\n"

" A list of FT2Font objects used to find missing glyphs.\n\n"

" .. warning::\n"

" This API is both private and provisional: do not use it directly\n\n"

"_kerning_factor : int, optional\n"

" Used to adjust the degree of kerning.\n\n"

" .. warning::\n"

" This API is private: do not use it directly\n\n"

"Attributes\n"

"----------\n"

"num_faces\n"

" Number of faces in file.\n"

"face_flags, style_flags : int\n"

" Face and style flags; see the ft2font constants.\n"

"num_glyphs\n"

" Number of glyphs in the face.\n"

"family_name, style_name\n"

" Face family and style name.\n"

"num_fixed_sizes\n"

" Number of bitmap in the face.\n"

"scalable\n"

" Whether face is scalable; attributes after this one are only\n"

" defined for scalable faces.\n"

"bbox\n"

" Face global bounding box (xmin, ymin, xmax, ymax).\n"

"units_per_EM\n"

" Number of font units covered by the EM.\n"

"ascender, descender\n"

" Ascender and descender in 26.6 units.\n"

"height\n"

" Height in 26.6 units; used to compute a default line spacing\n"

" (baseline-to-baseline distance).\n"

"max_advance_width, max_advance_height\n"

" Maximum horizontal and vertical cursor advance for all glyphs.\n"

"underline_position, underline_thickness\n"

" Vertical position and thickness of the underline bar.\n"

"postscript_name\n"

" PostScript name of the font.\n";

static int PyFT2Font_init(PyFT2Font *self, PyObject *args, PyObject *kwds)

}

static void PyFT2Font_dealloc(PyFT2Font *self)

}

const char *PyFT2Font_clear__doc__ =

"clear(self)\n"

"--\n\n"

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

static PyObject *PyFT2Font_clear(PyFT2Font *self, PyObject *args)

{

CALL_CPP("clear", (self->x->clear()));

Py_RETURN_NONE;

}

const char *PyFT2Font_set_size__doc__ =

"set_size(self, ptsize, dpi)\n"

"--\n\n"

"Set the point size and dpi of the text.\n";

static PyObject *PyFT2Font_set_size(PyFT2Font *self, PyObject *args)

{

double ptsize;

double dpi;

if (!PyArg_ParseTuple(args, "dd:set_size", &ptsize, &dpi)) {

return NULL;

}

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

Py_RETURN_NONE;

}

const char *PyFT2Font_set_charmap__doc__ =

"set_charmap(self, i)\n"

"--\n\n"

"Make the i-th charmap current.\n";

static PyObject *PyFT2Font_set_charmap(PyFT2Font *self, PyObject *args)

{

int i;

if (!PyArg_ParseTuple(args, "i:set_charmap", &i)) {

return NULL;

}

CALL_CPP("set_charmap", (self->x->set_charmap(i)));

Py_RETURN_NONE;

}

const char *PyFT2Font_select_charmap__doc__ =

"select_charmap(self, i)\n"

"--\n\n"

"Select a charmap by its FT_Encoding number.\n";

static PyObject *PyFT2Font_select_charmap(PyFT2Font *self, PyObject *args)

{

unsigned long i;

if (!PyArg_ParseTuple(args, "k:select_charmap", &i)) {

return NULL;

}

CALL_CPP("select_charmap", self->x->select_charmap(i));

Py_RETURN_NONE;

}

const char *PyFT2Font_get_kerning__doc__ =

"get_kerning(self, left, right, mode)\n"

"--\n\n"

"Get the kerning between *left* and *right* glyph indices.\n"

"*mode* is a kerning mode constant:\n\n"

" - KERNING_DEFAULT - Return scaled and grid-fitted kerning distances\n"

" - KERNING_UNFITTED - Return scaled but un-grid-fitted kerning distances\n"

" - KERNING_UNSCALED - Return the kerning vector in original font units\n";

static PyObject *PyFT2Font_get_kerning(PyFT2Font *self, PyObject *args)

{

FT_UInt left, right, mode;

int result;

int fallback = 1;

if (!PyArg_ParseTuple(args, "III:get_kerning", &left, &right, &mode)) {

return NULL;

}

CALL_CPP("get_kerning", (result = self->x->get_kerning(left, right, mode, (bool)fallback)));

return PyLong_FromLong(result);

}

const char *PyFT2Font_get_fontmap__doc__ =

"_get_fontmap(self, string)\n"

"--\n\n"

"Get a mapping between characters and the font that includes them.\n"

"A dictionary mapping unicode characters to PyFT2Font objects.";

static PyObject *PyFT2Font_get_fontmap(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

PyObject *textobj;

const char *names[] = { "string", NULL };

if (!PyArg_ParseTupleAndKeywords(

args, kwds, "O:_get_fontmap", (char **)names, &textobj)) {

return NULL;

}

std::set<FT_ULong> codepoints;

size_t size;

if (PyUnicode_Check(textobj)) {

size = PyUnicode_GET_LENGTH(textobj);

#if defined(PYPY_VERSION) && (PYPY_VERSION_NUM < 0x07040000)

// PyUnicode_ReadChar is available from PyPy 7.3.2, but wheels do not

// specify the micro-release version, so put the version bound at 7.4

// to prevent generating wheels unusable on PyPy 7.3.{0,1}.

Py_UNICODE *unistr = PyUnicode_AsUnicode(textobj);

for (size_t i = 0; i < size; ++i) {

codepoints.insert(unistr[i]);

}

#else

for (size_t i = 0; i < size; ++i) {

codepoints.insert(PyUnicode_ReadChar(textobj, i));

}

#endif

} else {

PyErr_SetString(PyExc_TypeError, "string must be str");

return NULL;

}

PyObject *char_to_font;

if (!(char_to_font = PyDict_New())) {

return NULL;

}

for (auto it = codepoints.begin(); it != codepoints.end(); ++it) {

auto x = *it;

PyObject* target_font;

int index;

if (self->x->get_char_fallback_index(x, index)) {

if (index >= 0) {

target_font = self->fallbacks[index];

} else {

target_font = (PyObject *)self;

}

} else {

// TODO Handle recursion!

target_font = (PyObject *)self;

}

PyObject *key = NULL;

bool error = (!(key = PyUnicode_FromFormat("%c", x))

|| (PyDict_SetItem(char_to_font, key, target_font) == -1));

Py_XDECREF(key);

if (error) {

Py_DECREF(char_to_font);

PyErr_SetString(PyExc_ValueError, "Something went very wrong");

return NULL;

}

}

return char_to_font;

}

const char *PyFT2Font_set_text__doc__ =

"set_text(self, string, angle, flags=32)\n"

"--\n\n"

"Set the text *string* and *angle*.\n"

"*flags* can be a bitwise-or of the LOAD_XXX constants;\n"

"the default value is LOAD_FORCE_AUTOHINT.\n"

"You must call this before `.draw_glyphs_to_bitmap`.\n"

"A sequence of x,y positions is returned.\n";

static PyObject *PyFT2Font_set_text(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

PyObject *textobj;

double angle = 0.0;

FT_Int32 flags = FT_LOAD_FORCE_AUTOHINT;

std::vector<double> xys;

const char *names[] = { "string", "angle", "flags", NULL };

/* This makes a technically incorrect assumption that FT_Int32 is

if (!PyArg_ParseTupleAndKeywords(

args, kwds, "O|di:set_text", (char **)names, &textobj, &angle, &flags)) {

return NULL;

}

std::vector<uint32_t> codepoints;

size_t size;

if (PyUnicode_Check(textobj)) {

size = PyUnicode_GET_LENGTH(textobj);

codepoints.resize(size);

#if defined(PYPY_VERSION) && (PYPY_VERSION_NUM < 0x07040000)

// PyUnicode_ReadChar is available from PyPy 7.3.2, but wheels do not

// specify the micro-release version, so put the version bound at 7.4

// to prevent generating wheels unusable on PyPy 7.3.{0,1}.

Py_UNICODE *unistr = PyUnicode_AsUnicode(textobj);

for (size_t i = 0; i < size; ++i) {

codepoints[i] = unistr[i];

}

#else

for (size_t i = 0; i < size; ++i) {

codepoints[i] = PyUnicode_ReadChar(textobj, i);

}

#endif

} else {

PyErr_SetString(PyExc_TypeError, "set_text requires str-input.");

return NULL;

}

uint32_t* codepoints_array = NULL;

if (size > 0) {

codepoints_array = &codepoints[0];

}

CALL_CPP("set_text", self->x->set_text(size, codepoints_array, angle, flags, xys));

return convert_xys_to_array(xys);

}

const char *PyFT2Font_get_num_glyphs__doc__ =

"get_num_glyphs(self)\n"

"--\n\n"

"Return the number of loaded glyphs.\n";

static PyObject *PyFT2Font_get_num_glyphs(PyFT2Font *self, PyObject *args)

{

return PyLong_FromSize_t(self->x->get_num_glyphs());

}

const char *PyFT2Font_load_char__doc__ =

"load_char(self, charcode, flags=32)\n"

"--\n\n"

"Load character with *charcode* in current fontfile and set glyph.\n"

"*flags* can be a bitwise-or of the LOAD_XXX constants;\n"

"the default value is LOAD_FORCE_AUTOHINT.\n"

"Return value is a Glyph object, with attributes\n\n"

"- width: glyph width\n"

"- height: glyph height\n"

"- bbox: the glyph bbox (xmin, ymin, xmax, ymax)\n"

"- horiBearingX: left side bearing in horizontal layouts\n"

"- horiBearingY: top side bearing in horizontal layouts\n"

"- horiAdvance: advance width for horizontal layout\n"

"- vertBearingX: left side bearing in vertical layouts\n"

"- vertBearingY: top side bearing in vertical layouts\n"

"- vertAdvance: advance height for vertical layout\n";

static PyObject *PyFT2Font_load_char(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

long charcode;

int fallback = 1;

FT_Int32 flags = FT_LOAD_FORCE_AUTOHINT;

const char *names[] = { "charcode", "flags", NULL };

/* This makes a technically incorrect assumption that FT_Int32 is

if (!PyArg_ParseTupleAndKeywords(args, kwds, "l|i:load_char", (char **)names, &charcode,

&flags)) {

return NULL;

}

FT2Font *ft_object = NULL;

CALL_CPP("load_char", (self->x->load_char(charcode, flags, ft_object, (bool)fallback)));

return PyGlyph_from_FT2Font(ft_object);

}

const char *PyFT2Font_load_glyph__doc__ =

"load_glyph(self, glyphindex, flags=32)\n"

"--\n\n"

"Load character with *glyphindex* in current fontfile and set glyph.\n"

"*flags* can be a bitwise-or of the LOAD_XXX constants;\n"

"the default value is LOAD_FORCE_AUTOHINT.\n"

"Return value is a Glyph object, with attributes\n\n"

"- width: glyph width\n"

"- height: glyph height\n"

"- bbox: the glyph bbox (xmin, ymin, xmax, ymax)\n"

"- horiBearingX: left side bearing in horizontal layouts\n"

"- horiBearingY: top side bearing in horizontal layouts\n"

"- horiAdvance: advance width for horizontal layout\n"

"- vertBearingX: left side bearing in vertical layouts\n"

"- vertBearingY: top side bearing in vertical layouts\n"

"- vertAdvance: advance height for vertical layout\n";

static PyObject *PyFT2Font_load_glyph(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

FT_UInt glyph_index;

FT_Int32 flags = FT_LOAD_FORCE_AUTOHINT;

int fallback = 1;

const char *names[] = { "glyph_index", "flags", NULL };

/* This makes a technically incorrect assumption that FT_Int32 is

if (!PyArg_ParseTupleAndKeywords(args, kwds, "I|i:load_glyph", (char **)names, &glyph_index,

&flags)) {

return NULL;

}

FT2Font *ft_object = NULL;

CALL_CPP("load_glyph", (self->x->load_glyph(glyph_index, flags, ft_object, (bool)fallback)));

return PyGlyph_from_FT2Font(ft_object);

}

const char *PyFT2Font_get_width_height__doc__ =

"get_width_height(self)\n"

"--\n\n"

"Get the width and height in 26.6 subpixels of the current string set by `.set_text`.\n"

"The rotation of the string is accounted for. To get width and height\n"

"in pixels, divide these values by 64.\n";

static PyObject *PyFT2Font_get_width_height(PyFT2Font *self, PyObject *args)

{

long width, height;

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

return Py_BuildValue("ll", width, height);

}

const char *PyFT2Font_get_bitmap_offset__doc__ =

"get_bitmap_offset(self)\n"

"--\n\n"

"Get the (x, y) offset in 26.6 subpixels for the bitmap if ink hangs left or below (0, 0).\n"

"Since Matplotlib only supports left-to-right text, y is always 0.\n";

static PyObject *PyFT2Font_get_bitmap_offset(PyFT2Font *self, PyObject *args)

{

long x, y;

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

return Py_BuildValue("ll", x, y);

}

const char *PyFT2Font_get_descent__doc__ =

"get_descent(self)\n"

"--\n\n"

"Get the descent in 26.6 subpixels of the current string set by `.set_text`.\n"

"The rotation of the string is accounted for. To get the descent\n"

"in pixels, divide this value by 64.\n";

static PyObject *PyFT2Font_get_descent(PyFT2Font *self, PyObject *args)

{

long descent;

CALL_CPP("get_descent", (descent = self->x->get_descent()));

return PyLong_FromLong(descent);

}

const char *PyFT2Font_draw_glyphs_to_bitmap__doc__ =

"draw_glyphs_to_bitmap(self, antialiased=True)\n"

"--\n\n"

"Draw the glyphs that were loaded by `.set_text` to the bitmap.\n"

"The bitmap size will be automatically set to include the glyphs.\n";

static PyObject *PyFT2Font_draw_glyphs_to_bitmap(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

bool antialiased = true;

const char *names[] = { "antialiased", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&:draw_glyphs_to_bitmap",

(char **)names, &convert_bool, &antialiased)) {

return NULL;

}

CALL_CPP("draw_glyphs_to_bitmap", (self->x->draw_glyphs_to_bitmap(antialiased)));

Py_RETURN_NONE;

}

const char *PyFT2Font_get_xys__doc__ =

"get_xys(self, antialiased=True)\n"

"--\n\n"

"Get the xy locations of the current glyphs.\n";

static PyObject *PyFT2Font_get_xys(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

bool antialiased = true;

std::vector<double> xys;

const char *names[] = { "antialiased", NULL };

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&:get_xys",

(char **)names, &convert_bool, &antialiased)) {

return NULL;

}

CALL_CPP("get_xys", (self->x->get_xys(antialiased, xys)));

return convert_xys_to_array(xys);

}

const char *PyFT2Font_draw_glyph_to_bitmap__doc__ =

"draw_glyph_to_bitmap(self, image, x, y, glyph, antialiased=True)\n"

"--\n\n"

"Draw a single glyph to the bitmap at pixel locations x, y\n"

"Note it is your responsibility to set up the bitmap manually\n"

"with ``set_bitmap_size(w, h)`` before this call is made.\n"

"\n"

"If you want automatic layout, use `.set_text` in combinations with\n"

"`.draw_glyphs_to_bitmap`. This function is instead intended for people\n"

"who want to render individual glyphs (e.g., returned by `.load_char`)\n"

"at precise locations.\n";

static PyObject *PyFT2Font_draw_glyph_to_bitmap(PyFT2Font *self, PyObject *args, PyObject *kwds)

{

PyFT2Image *image;

double xd, yd;

PyGlyph *glyph;

bool antialiased = true;

const char *names[] = { "image", "x", "y", "glyph", "antialiased", NULL };

if (!PyArg_ParseTupleAndKeywords(args,

kwds,

"O!ddO!|O&:draw_glyph_to_bitmap",

(char **)names,

&PyFT2ImageType,

&image,

&xd,

&yd,

&PyGlyphType,

&glyph,

&convert_bool,

&antialiased)) {

return NULL;

}

CALL_CPP("draw_glyph_to_bitmap",

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

Py_RETURN_NONE;

}

const char *PyFT2Font_get_glyph_name__doc__ =

"get_glyph_name(self, index)\n"

"--\n\n"

"Retrieve the ASCII name of a given glyph *index* in a face.\n"

"\n"

"Due to Matplotlib's internal design, for fonts that do not contain glyph\n"

"names (per FT_FACE_FLAG_GLYPH_NAMES), this returns a made-up name which\n"

"does *not* roundtrip through `.get_name_index`.\n";

static PyObject *PyFT2Font_get_glyph_name(PyFT2Font *self, PyObject *args)

{

unsigned int glyph_number;

char buffer[128];

int fallback = 1;

if (!PyArg_ParseTuple(args, "I:get_glyph_name", &glyph_number)) {

return NULL;

}

CALL_CPP("get_glyph_name", (self->x->get_glyph_name(glyph_number, buffer, (bool)fallback)));

return PyUnicode_FromString(buffer);

}

const char *PyFT2Font_get_charmap__doc__ =

"get_charmap(self)\n"

"--\n\n"

"Return a dict that maps the character codes of the selected charmap\n"

"(Unicode by default) to their corresponding glyph indices.\n";

static PyObject *PyFT2Font_get_charmap(PyFT2Font *self, PyObject *args)

{

PyObject *charmap;

if (!(charmap = PyDict_New())) {

return NULL;

}

FT_UInt index;

FT_ULong code = FT_Get_First_Char(self->x->get_face(), &index);

while (index != 0) {

PyObject *key = NULL, *val = NULL;

bool error = (!(key = PyLong_FromLong(code))

|| !(val = PyLong_FromLong(index))

|| (PyDict_SetItem(charmap, key, val) == -1));

Py_XDECREF(key);

Py_XDECREF(val);

if (error) {

Py_DECREF(charmap);

return NULL;

}

code = FT_Get_Next_Char(self->x->get_face(), code, &index);

}

return charmap;

}

const char *PyFT2Font_get_char_index__doc__ =

"get_char_index(self, codepoint)\n"

"--\n\n"

"Return the glyph index corresponding to a character *codepoint*.\n";

static PyObject *PyFT2Font_get_char_index(PyFT2Font *self, PyObject *args)

{

FT_UInt index;

FT_ULong ccode;

int fallback = 1;

if (!PyArg_ParseTuple(args, "k:get_char_index", &ccode)) {

return NULL;

}

CALL_CPP("get_char_index", index = self->x->get_char_index(ccode, (bool)fallback));

return PyLong_FromLong(index);

}

const char *PyFT2Font_get_sfnt__doc__ =

"get_sfnt(self)\n"

"--\n\n"

"Load the entire SFNT names table, as a dict whose keys are\n"

"(platform-ID, ISO-encoding-scheme, language-code, and description)\n"

"tuples.\n";

static PyObject *PyFT2Font_get_sfnt(PyFT2Font *self, PyObject *args)

{

PyObject *names;

if (!(self->x->get_face()->face_flags & FT_FACE_FLAG_SFNT)) {

PyErr_SetString(PyExc_ValueError, "No SFNT name table");

return NULL;

}

size_t count = FT_Get_Sfnt_Name_Count(self->x->get_face());

names = PyDict_New();

if (names == NULL) {

return NULL;

}

for (FT_UInt j = 0; j < count; ++j) {

FT_SfntName sfnt;