#include "mplutils.h"

#include "ft2font.h"

#include "py_converters.h"

#include "py_exceptions.h"

#include "numpy_cpp.h"

#include <structmember.h>

#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 FT_Glyph &glyph = font->get_last_glyph();

size_t ind = font->get_last_glyph_index();

long hinting_factor = font->get_hinting_factor();

PyGlyph *self;

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

self->glyphInd = ind;

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;

}

typedef struct

{

PyObject_HEAD

FT2Font *x;

PyObject *py_file;

FT_StreamRec stream;

Py_ssize_t shape[2];

Py_ssize_t strides[2];

Py_ssize_t suboffsets[2];

} 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(ttffile)\n"

"--\n\n"

"Create a new FT2Font object.\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"

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

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

return NULL;

}

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

return PyLong_FromLong(result);

}

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 if (PyBytes_Check(textobj)) {

if (PyErr_WarnEx(

PyExc_FutureWarning,

"Passing bytes to FTFont.set_text is deprecated since Matplotlib "

"3.4 and support will be removed in Matplotlib 3.6; pass str instead",

1)) {

return NULL;

}

size = PyBytes_Size(textobj);

codepoints.resize(size);

char *bytestr = PyBytes_AsString(textobj);

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

codepoints[i] = bytestr[i];

}

} else {

PyErr_SetString(PyExc_TypeError, "String must be str or bytes");

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"

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

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;

}

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

return PyGlyph_from_FT2Font(self->x);

}

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"

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

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;

}

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

return PyGlyph_from_FT2Font(self->x);

}

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

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

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;

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

return NULL;

}

index = FT_Get_Char_Index(self->x->get_face(), ccode);

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;

FT_Error error = FT_Get_Sfnt_Name(self->x->get_face(), j, &sfnt);

if (error) {

Py_DECREF(names);

PyErr_SetString(PyExc_ValueError, "Could not get SFNT name");

return NULL;

}

PyObject *key = Py_BuildValue(

"HHHH", sfnt.platform_id, sfnt.encoding_id, sfnt.language_id, sfnt.name_id);

if (key == NULL) {

Py_DECREF(names);

return NULL;

}

PyObject *val = PyBytes_FromStringAndSize((const char *)sfnt.string, sfnt.string_len);

if (val == NULL) {

Py_DECREF(key);

Py_DECREF(names);

return NULL;

}

if (PyDict_SetItem(names, key, val)) {

Py_DECREF(key);

Py_DECREF(val);

Py_DECREF(names);

return NULL;

}

Py_DECREF(key);

Py_DECREF(val);

}

return names;

}

const char *PyFT2Font_get_name_index__doc__ =

"get_name_index(self, name)\n"

"--\n\n"

"Return the glyph index of a given glyph *name*.\n"

"The glyph index 0 means 'undefined character code'.\n";

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

{

char *glyphname;

long name_index;

if (!PyArg_ParseTuple(args, "s:get_name_index", &glyphname)) {

return NULL;

}

CALL_CPP("get_name_index", name_index = self->x->get_name_index(glyphname));

return PyLong_FromLong(name_index);

}

const char *PyFT2Font_get_ps_font_info__doc__ =

"get_ps_font_info(self)\n"

"--\n\n"

"Return the information in the PS Font Info structure.\n";

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

{

PS_FontInfoRec fontinfo;

FT_Error error = FT_Get_PS_Font_Info(self->x->get_face(), &fontinfo);

if (error) {

PyErr_SetString(PyExc_ValueError, "Could not get PS font info");

return NULL;

}

return Py_BuildValue("ssssslbhH",

fontinfo.version ? fontinfo.version : "",

fontinfo.notice ? fontinfo.notice : "",

fontinfo.full_name ? fontinfo.full_name : "",

fontinfo.family_name ? fontinfo.family_name : "",

fontinfo.weight ? fontinfo.weight : "",

fontinfo.italic_angle,

fontinfo.is_fixed_pitch,

fontinfo.underline_position,

fontinfo.underline_thickness);

}

const char *PyFT2Font_get_sfnt_table__doc__ =

"get_sfnt_table(self, name)\n"

"--\n\n"

"Return one of the following SFNT tables: head, maxp, OS/2, hhea, "

"vhea, post, or pclt.\n";

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

{

char *tagname;

if (!PyArg_ParseTuple(args, "s:get_sfnt_table", &tagname)) {

return NULL;

}

int tag;

const char *tags[] = { "head", "maxp", "OS/2", "hhea", "vhea", "post", "pclt", NULL };

for (tag = 0; tags[tag] != NULL; tag++) {

if (strncmp(tagname, tags[tag], 5) == 0) {

break;

}

}

void *table = FT_Get_Sfnt_Table(self->x->get_face(), (FT_Sfnt_Tag)tag);

if (!table) {

Py_RETURN_NONE;

}

switch (tag) {

case 0: {

char head_dict[] =

"{s:(h,H), s:(h,H), s:l, s:l, s:H, s:H,"

"s:(l,l), s:(l,l), s:h, s:h, s:h, s:h, s:H, s:H, s:h, s:h, s:h}";

TT_Header *t = (TT_Header *)table;

return Py_BuildValue(head_dict,

"version",

FIXED_MAJOR(t->Table_Version),

FIXED_MINOR(t->Table_Version),

"fontRevision",

FIXED_MAJOR(t->Font_Revision),

FIXED_MINOR(t->Font_Revision),

"checkSumAdjustment",