#include "mplutils.h"

#include "ft2font.h"

#include "file_compat.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 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(x0, y0, x1, y1)\n"

"\n"

"Draw a rect to the image.\n"

"\n";

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

{

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(x0, y0, x1, y1)\n"

"\n"

"Draw a filled rect to the image.\n"

"\n";

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

{

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;

}

const char *PyFT2Image_as_str__doc__ =

"s = image.as_str()\n"

"\n"

"Return the image buffer as a string\n"

"\n";

static PyObject *PyFT2Image_as_str(PyFT2Image *self, PyObject *args, PyObject *kwds)

{

// TODO: Use a buffer to avoid the copy

return PyBytes_FromStringAndSize((const char *)self->x->get_buffer(),

self->x->get_width() * self->x->get_height());

}

const char *PyFT2Image_as_rgba_str__doc__ =

"s = image.as_rgba_str()\n"

"\n"

"Return the image buffer as a RGBA string\n"

"\n";

static PyObject *PyFT2Image_as_rgba_str(PyFT2Image *self, PyObject *args, PyObject *kwds)

{

npy_intp dims[] = {(npy_intp)self->x->get_height(), (npy_intp)self->x->get_width(), 4 };

numpy::array_view<unsigned char, 3> result(dims);

unsigned char *src = self->x->get_buffer();

unsigned char *end = src + (self->x->get_width() * self->x->get_height());

unsigned char *dst = result.data();

while (src != end) {

*dst++ = 0;

*dst++ = 0;

*dst++ = 0;

*dst++ = *src++;

}

return result.pyobj();

}

const char *PyFT2Image_as_array__doc__ =

"x = image.as_array()\n"

"\n"

"Return the image buffer as a width x height numpy array of ubyte \n"

"\n";

static PyObject *PyFT2Image_as_array(PyFT2Image *self, PyObject *args, PyObject *kwds)

{

npy_intp dims[] = {(npy_intp)self->x->get_height(), (npy_intp)self->x->get_width() };

return PyArray_SimpleNewFromData(2, dims, NPY_UBYTE, self->x->get_buffer());

}

static PyObject *PyFT2Image_get_width(PyFT2Image *self, PyObject *args, PyObject *kwds)

{

return PyLong_FromLong(self->x->get_width());

}

static PyObject *PyFT2Image_get_height(PyFT2Image *self, PyObject *args, PyObject *kwds)

{

return PyLong_FromLong(self->x->get_height());

}

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

}

static PyTypeObject PyFT2ImageType;

static PyTypeObject *PyFT2Image_init_type(PyObject *m, PyTypeObject *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__},

{"as_str", (PyCFunction)PyFT2Image_as_str, METH_NOARGS, PyFT2Image_as_str__doc__},

{"as_rgba_str", (PyCFunction)PyFT2Image_as_rgba_str, METH_NOARGS, PyFT2Image_as_rgba_str__doc__},

{"as_array", (PyCFunction)PyFT2Image_as_array, METH_NOARGS, PyFT2Image_as_array__doc__},

{"get_width", (PyCFunction)PyFT2Image_get_width, METH_NOARGS, NULL},

{"get_height", (PyCFunction)PyFT2Image_get_height, METH_NOARGS, NULL},

{NULL}

};

static PyBufferProcs buffer_procs;

memset(&buffer_procs, 0, sizeof(PyBufferProcs));

buffer_procs.bf_getbuffer = (getbufferproc)PyFT2Image_get_buffer;

memset(type, 0, sizeof(PyTypeObject));

type->tp_name = "matplotlib.ft2font.FT2Image";

type->tp_basicsize = sizeof(PyFT2Image);

type->tp_dealloc = (destructor)PyFT2Image_dealloc;

type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_NEWBUFFER;

type->tp_methods = methods;

type->tp_new = PyFT2Image_new;

type->tp_init = (initproc)PyFT2Image_init;

type->tp_as_buffer = &buffer_procs;

if (PyType_Ready(type) < 0) {

return NULL;

}

if (PyModule_AddObject(m, "FT2Image", (PyObject *)type)) {

return NULL;

}

return type;

}

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_new(const FT_Face &face, const FT_Glyph &glyph, size_t ind, long 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(

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

}

static PyTypeObject *PyGlyph_init_type(PyObject *m, PyTypeObject *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}

};

memset(type, 0, sizeof(PyTypeObject));

type->tp_name = "matplotlib.ft2font.Glyph";

type->tp_basicsize = sizeof(PyGlyph);

type->tp_dealloc = (destructor)PyGlyph_dealloc;

type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

type->tp_members = members;

type->tp_getset = getset;

if (PyType_Ready(type) < 0) {

return NULL;

}

/* Don't need to add to module, since you can't create glyphs

return type;

}

typedef struct

{

PyObject_HEAD

FT2Font *x;

PyObject *fname;

PyObject *py_file;

FILE *fp;

int close_file;

mpl_off_t offset;

FT_StreamRec stream;

FT_Byte *mem;

size_t mem_size;

Py_ssize_t shape[2];

Py_ssize_t strides[2];

Py_ssize_t suboffsets[2];

} PyFT2Font;

static unsigned long read_from_file_callback(FT_Stream stream,

}

static void close_file_callback(FT_Stream stream)

}

static int convert_open_args(PyFT2Font *self, PyObject *py_file_arg, FT_Open_Args *open_args)

}

static PyTypeObject PyFT2FontType;

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

{

PyFT2Font *self;

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

self->x = NULL;

self->fname = NULL;

self->py_file = NULL;

self->fp = NULL;

self->close_file = 0;

self->offset = 0;

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

self->mem = 0;

self->mem_size = 0;

return (PyObject *)self;

}

const char *PyFT2Font_init__doc__ =

"FT2Font(ttffile)\n"

"\n"

"Create a new FT2Font object\n"

"The following global font attributes are defined:\n"

" num_faces number of faces in file\n"

" face_flags face flags (int type); see the ft2font constants\n"

" style_flags style flags (int type); see the ft2font constants\n"

" num_glyphs number of glyphs in the face\n"

" family_name face family name\n"

" style_name face style name\n"

" num_fixed_sizes number of bitmap in the face\n"

" scalable face is scalable\n"

"\n"

"The following are available, if scalable is true:\n"

" bbox face global bounding box (xmin, ymin, xmax, ymax)\n"

" units_per_EM number of font units covered by the EM\n"

" ascender ascender in 26.6 units\n"

" descender descender in 26.6 units\n"

" height height in 26.6 units; used to compute a default\n"

" line spacing (baseline-to-baseline distance)\n"

" max_advance_width maximum horizontal cursor advance for all glyphs\n"

" max_advance_height same for vertical layout\n"

" underline_position vertical position of the underline bar\n"

" underline_thickness vertical thickness of the underline\n"

" postscript_name PostScript name of the font\n";

static void PyFT2Font_fail(PyFT2Font *self)

}

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

}

static void PyFT2Font_dealloc(PyFT2Font *self)

}

const char *PyFT2Font_clear__doc__ =

"clear()\n"

"\n"

"Clear all the glyphs, reset for a new set_text";

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

{

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

Py_RETURN_NONE;

}

const char *PyFT2Font_set_size__doc__ =

"set_size(ptsize, dpi)\n"

"\n"

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

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

{

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

"\n"

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

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

{

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

"\n"

"select charmap i where i is one of the FT_Encoding number\n";

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

{

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__ =

"dx = get_kerning(left, right, mode)\n"

"\n"

"Get the kerning between left char 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, PyObject *kwds)

{

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(s, angle)\n"

"\n"

"Set the text string and angle.\n"

"You must call this before draw_glyphs_to_bitmap\n"

"A sequence of x,y positions is returned";

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

codepoints.resize(size);

Py_UNICODE *unistr = PyUnicode_AsUnicode(textobj);

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

codepoints[i] = unistr[i];

}

} else if (PyBytes_Check(textobj)) {

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

"\n"

"Return the number of loaded glyphs\n";

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

{

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

}

const char *PyFT2Font_load_char__doc__ =

"load_char(charcode, flags=LOAD_FORCE_AUTOHINT)\n"

"\n"

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

"The flags argument can be a bitwise-or of the LOAD_XXX constants.\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_new(self->x->get_face(),

self->x->get_last_glyph(),

self->x->get_last_glyph_index(),

self->x->get_hinting_factor());

}

const char *PyFT2Font_load_glyph__doc__ =

"load_glyph(glyphindex, flags=LOAD_FORCE_AUTOHINT)\n"

"\n"

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

"The flags argument can be a bitwise-or of the LOAD_XXX constants.\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_new(self->x->get_face(),

self->x->get_last_glyph(),

self->x->get_last_glyph_index(),

self->x->get_hinting_factor());

}

const char *PyFT2Font_get_width_height__doc__ =

"w, h = get_width_height()\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, PyObject *kwds)

{

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__ =

"x, y = get_bitmap_offset()\n"

"\n"

"Get the 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, PyObject *kwds)

{

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__ =

"d = get_descent()\n"

"\n"

"Get the descent of the current string set by set_text in 26.6 subpixels.\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, PyObject *kwds)

{

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()\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()\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(bitmap, x, y, glyph)\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 intended for people who\n"

"want to render individual glyphs at precise locations, eg, a\n"

"a glyph returned by load_char\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(index)\n"

"\n"

"Retrieves the ASCII name of a given glyph in a face.\n";

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

{

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

"\n"

"Returns a dictionary 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 *kwds)

{

PyObject *charmap;

charmap = PyDict_New();

if (charmap == NULL) {

return NULL;

}

FT_UInt index;

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

while (index != 0) {

PyObject *key;

PyObject *val;

key = PyLong_FromLong(code);

if (key == NULL) {

Py_DECREF(charmap);

return NULL;

}

val = PyLong_FromLong(index);

if (val == NULL) {

Py_DECREF(key);

Py_DECREF(charmap);

return NULL;

}

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

Py_DECREF(key);

Py_DECREF(val);

Py_DECREF(charmap);

return NULL;

}

Py_DECREF(key);

Py_DECREF(val);

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

}

return charmap;

}

const char *PyFT2Font_get_char_index__doc__ =

"get_char_index()\n"

"\n"

"Given a character code, returns a glyph index.\n";

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

{

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

"\n"