Py::PythonClass< FT2Image >(self, args, kwds),

_isDirty(true),

_buffer(NULL),

_width(0), _height(0)

{

_VERBOSE("FT2Image::FT2Image");

args.verify_length(2);

int width = Py::Int(args[0]);

int height = Py::Int(args[1]);

resize(width, height);

{

Py::Callable class_type(type());

Py::Tuple args(2);

args[0] = Py::Int(width);

args[1] = Py::Int(height);

Py::PythonClassObject<FT2Image> o = Py::PythonClassObject<FT2Image>(

class_type.apply(args, Py::Dict()));

return o;

{

if (width < 0)

{

width = 1;

}

if (height < 0)

{

height = 1;

}

size_t numBytes = width * height;

if ((unsigned long)width != _width || (unsigned long)height != _height)

{

if (numBytes > _width*_height)

{

delete [] _buffer;

_buffer = NULL;

_buffer = new unsigned char [numBytes];

}

_width = (unsigned long)width;

_height = (unsigned long)height;

}

memset(_buffer, 0, numBytes);

_isDirty = true;

FT_Int x,

FT_Int y)

{

_VERBOSE("FT2Image::draw_bitmap");

FT_Int image_width = (FT_Int)_width;

FT_Int image_height = (FT_Int)_height;

FT_Int char_width = bitmap->width;

FT_Int char_height = bitmap->rows;

FT_Int x1 = CLAMP(x, 0, image_width);

FT_Int y1 = CLAMP(y, 0, image_height);

FT_Int x2 = CLAMP(x + char_width, 0, image_width);

FT_Int y2 = CLAMP(y + char_height, 0, image_height);

FT_Int x_start = MAX(0, -x);

FT_Int y_offset = y1 - MAX(0, -y);

if (bitmap->pixel_mode == FT_PIXEL_MODE_GRAY) {

for (FT_Int i = y1; i < y2; ++i)

{

unsigned char* dst = _buffer + (i * image_width + x1);

unsigned char* src = bitmap->buffer + (((i - y_offset) * bitmap->pitch) + x_start);

for (FT_Int j = x1; j < x2; ++j, ++dst, ++src)

*dst |= *src;

}

} else if (bitmap->pixel_mode == FT_PIXEL_MODE_MONO) {

for (FT_Int i = y1; i < y2; ++i)

{

unsigned char* dst = _buffer + (i * image_width + x1);

unsigned char* src = bitmap->buffer + ((i - y_offset) * bitmap->pitch);

for (FT_Int j = x1; j < x2; ++j, ++dst) {

int x = (j - x1 + x_start);

int val = *(src + (x >> 3)) & (1 << (7 - (x & 0x7)));

*dst = val ? 255 : *dst;

}

}

} else {

throw Py::Exception("Unknown pixel mode");

}

_isDirty = true;

{

for (size_t i = 0; i < _height; i++)

{

for (size_t j = 0; j < _width; ++j)

{

if (_buffer[j + i*_width])

{

fputc('#', fh);

}

else

{

fputc(' ', fh);

}

}

fputc('\n', fh);

}

{

_VERBOSE("FT2Image::write_bitmap");

PyObject *py_file;

FILE *fh;

mpl_off_t offset;

args.verify_length(1);

if ((py_file = mpl_PyFile_OpenFile(args[0].ptr(), (char *)"wb")) == NULL) {

throw Py::Exception();

}

fh = mpl_PyFile_Dup(py_file, (char *)"wb", &offset);

write_bitmap(fh);

if (mpl_PyFile_DupClose(py_file, fh, offset))

{

throw Py::Exception();

}

mpl_PyFile_CloseFile(py_file);

Py_DECREF(py_file);

return Py::Object();

unsigned long x1, unsigned long y1)

{

if (x0 > _width || x1 > _width ||

y0 > _height || y1 > _height)

{

throw Py::ValueError("Rect coords outside image bounds");

}

size_t top = y0 * _width;

size_t bottom = y1 * _width;

for (size_t i = x0; i < x1 + 1; ++i)

{

_buffer[i + top] = 255;

_buffer[i + bottom] = 255;

}

for (size_t j = y0 + 1; j < y1; ++j)

{

_buffer[x0 + j*_width] = 255;

_buffer[x1 + j*_width] = 255;

}

_isDirty = true;

{

_VERBOSE("FT2Image::draw_rect");

args.verify_length(4);

long x0 = Py::Int(args[0]);

long y0 = Py::Int(args[1]);

long x1 = Py::Int(args[2]);

long y1 = Py::Int(args[3]);

draw_rect(x0, y0, x1, y1);

return Py::Object();

unsigned long x1, unsigned long y1)

{

x0 = std::min(x0, _width);

y0 = std::min(y0, _height);

x1 = std::min(x1, _width);

y1 = std::min(y1, _height);

for (size_t j = y0; j < y1 + 1; j++)

{

for (size_t i = x0; i < x1 + 1; i++)

{

_buffer[i + j*_width] = 255;

}

}

_isDirty = true;

{

_VERBOSE("FT2Image::draw_rect_filled");

args.verify_length(4);

long x0 = Py::Int(args[0]);

long y0 = Py::Int(args[1]);

long x1 = Py::Int(args[2]);

long y1 = Py::Int(args[3]);

draw_rect_filled(x0, y0, x1, y1);

return Py::Object();

{

_VERBOSE("FT2Image::as_str");

args.verify_length(0);

return Py::asObject

(PyBytes_FromStringAndSize((const char *)_buffer, _width*_height));

{

_VERBOSE("FT2Image::as_str");

args.verify_length(0);

Py_ssize_t size = _width*_height*4;

PyObject* result = PyBytes_FromStringAndSize(NULL, size);

unsigned char *src = _buffer;

unsigned char *src_end = src + (_width * _height);

unsigned char *dst = (unsigned char *)PyBytes_AS_STRING(result);

while (src != src_end)

{

*dst++ = 0;

*dst++ = 0;

*dst++ = 0;

*dst++ = *src++;

}

return Py::asObject(result);

{

_VERBOSE("FT2Image::as_str");

args.verify_length(0);

Py_ssize_t size = _width*_height*3;

PyObject* result = PyBytes_FromStringAndSize(NULL, size);

unsigned char *src = _buffer;

unsigned char *src_end = src + (_width * _height);

unsigned char *dst = (unsigned char *)PyBytes_AS_STRING(result);

while (src != src_end)

{

unsigned char tmp = 255 - *src++;

*dst++ = tmp;

*dst++ = tmp;

*dst++ = tmp;

}

return Py::asObject(result);

{

_VERBOSE("FT2Image::as_array");

args.verify_length(0);

npy_intp dimensions[2];

dimensions[0] = get_height(); //numrows

dimensions[1] = get_width(); //numcols

PyArrayObject *A = (PyArrayObject *) PyArray_SimpleNewFromData(2, dimensions, PyArray_UBYTE, _buffer);

return Py::asObject((PyObject*)A);

{

_VERBOSE("FT2Image::get_width");

args.verify_length(0);

return Py::Int((long)get_width());

{

_VERBOSE("FT2Image::get_height");

args.verify_length(0);

return Py::Int((long)get_height());

const FT_Face& face, const FT_Glyph& glyph, size_t ind, long hinting_factor)

{

Py::Callable class_type(type());

Py::PythonClassObject<Glyph> obj = Py::PythonClassObject<Glyph>(

class_type.apply(Py::Tuple(), Py::Dict()));

Glyph* o = obj.getCxxObject();

o->glyphInd = ind;

FT_BBox bbox;

FT_Glyph_Get_CBox(glyph, ft_glyph_bbox_subpixels, &bbox);

o->setattro("width", Py::Int(face->glyph->metrics.width / hinting_factor));

o->setattro("height", Py::Int(face->glyph->metrics.height));

o->setattro("horiBearingX", Py::Int(face->glyph->metrics.horiBearingX / hinting_factor));

o->setattro("horiBearingY", Py::Int(face->glyph->metrics.horiBearingY));

o->setattro("horiAdvance", Py::Int(face->glyph->metrics.horiAdvance));

o->setattro("linearHoriAdvance", Py::Int(face->glyph->linearHoriAdvance / hinting_factor));

o->setattro("vertBearingX", Py::Int(face->glyph->metrics.vertBearingX));

o->setattro("vertBearingY", Py::Int(face->glyph->metrics.vertBearingY));

o->setattro("vertAdvance", Py::Int(face->glyph->metrics.vertAdvance));

Py::Tuple abbox(4);

abbox[0] = Py::Int(bbox.xMin);

abbox[1] = Py::Int(bbox.yMin);

abbox[2] = Py::Int(bbox.xMax);

abbox[3] = Py::Int(bbox.yMax);

o->setattro("bbox", abbox);

return obj;

{

_VERBOSE("Glyph::setattr");

__dict__[name] = value;

return 0;

{

_VERBOSE("Glyph::getattr");

if (__dict__.hasKey(name)) return __dict__[name];

else return genericGetAttro(name);

{

//get the glyph as a path, a list of (COMMAND, *args) as desribed in matplotlib.path

// this code is from agg's decompose_ft_outline with minor modifications

if (!face->glyph) {

throw Py::ValueError("No glyph loaded");

}

enum {STOP = 0,

MOVETO = 1,

LINETO = 2,

CURVE3 = 3,

CURVE4 = 4,

ENDPOLY = 0x4f};

FT_Outline& outline = face->glyph->outline;

bool flip_y = false; //todo, pass me as kwarg

FT_Vector v_last;

FT_Vector v_control;

FT_Vector v_start;

FT_Vector* point;

FT_Vector* limit;

char* tags;

int n; // index of contour in outline

int first; // index of first point in contour

char tag; // current point's state

int count;

count = 0;

first = 0;

for (n = 0; n < outline.n_contours; n++)

{

int last; // index of last point in contour

bool starts_with_last;

last = outline.contours[n];

limit = outline.points + last;

v_start = outline.points[first];

v_last = outline.points[last];

v_control = v_start;

point = outline.points + first;

tags = outline.tags + first;

tag = FT_CURVE_TAG(tags[0]);

// A contour cannot start with a cubic control point!

if (tag == FT_CURVE_TAG_CUBIC)

{

throw Py::RuntimeError("A contour cannot start with a cubic control point");

}

else if (tag == FT_CURVE_TAG_CONIC)

{

starts_with_last = true;

} else {

starts_with_last = false;

}

count++;

while (point < limit)

{

if (!starts_with_last) {

point++;

tags++;

}

starts_with_last = false;

tag = FT_CURVE_TAG(tags[0]);

switch (tag)

{

case FT_CURVE_TAG_ON: // emit a single line_to

{

count++;

continue;

}

case FT_CURVE_TAG_CONIC: // consume conic arcs

{

Count_Do_Conic:

if (point < limit)

{

point++;

tags++;

tag = FT_CURVE_TAG(tags[0]);

if (tag == FT_CURVE_TAG_ON)

{

count += 2;

continue;

}

if (tag != FT_CURVE_TAG_CONIC)

{

throw Py::RuntimeError("Invalid font");

}

count += 2;

goto Count_Do_Conic;

}

count += 2;

goto Count_Close;

}

default: // FT_CURVE_TAG_CUBIC

{

if (point + 1 > limit || FT_CURVE_TAG(tags[1]) != FT_CURVE_TAG_CUBIC)

{

throw Py::RuntimeError("Invalid font");

}

point += 2;

tags += 2;

if (point <= limit)

{

count += 3;

continue;

}

count += 3;

goto Count_Close;

}

}

}

count++;

Count_Close:

first = last + 1;

}

PyArrayObject* vertices = NULL;

PyArrayObject* codes = NULL;

Py::Tuple result(2);

npy_intp vertices_dims[2] = {count, 2};

vertices = (PyArrayObject*)PyArray_SimpleNew(

2, vertices_dims, PyArray_DOUBLE);

if (vertices == NULL) {

throw;

}

npy_intp codes_dims[1] = {count};

codes = (PyArrayObject*)PyArray_SimpleNew(

1, codes_dims, PyArray_UINT8);

if (codes == NULL) {

throw;

}

result[0] = Py::Object((PyObject*)vertices, true);

result[1] = Py::Object((PyObject*)codes, true);

double* outpoints = (double *)PyArray_DATA(vertices);

unsigned char* outcodes = (unsigned char *)PyArray_DATA(codes);

first = 0;

for (n = 0; n < outline.n_contours; n++)

{

int last; // index of last point in contour

bool starts_with_last;

last = outline.contours[n];

limit = outline.points + last;

v_start = outline.points[first];

v_last = outline.points[last];

v_control = v_start;

point = outline.points + first;

tags = outline.tags + first;

tag = FT_CURVE_TAG(tags[0]);

double x, y;

if (tag != FT_CURVE_TAG_ON)

{

x = conv(v_last.x);

y = flip_y ? -conv(v_last.y) : conv(v_last.y);

starts_with_last = true;

} else {

x = conv(v_start.x);

y = flip_y ? -conv(v_start.y) : conv(v_start.y);

starts_with_last = false;

}

*(outpoints++) = x;

*(outpoints++) = y;

*(outcodes++) = MOVETO;

while (point < limit)

{

if (!starts_with_last) {

point++;

tags++;

}

starts_with_last = false;

tag = FT_CURVE_TAG(tags[0]);

switch (tag)

{

case FT_CURVE_TAG_ON: // emit a single line_to

{

double x = conv(point->x);

double y = flip_y ? -conv(point->y) : conv(point->y);

*(outpoints++) = x;

*(outpoints++) = y;

*(outcodes++) = LINETO;

continue;

}

case FT_CURVE_TAG_CONIC: // consume conic arcs

{

v_control.x = point->x;

v_control.y = point->y;

Do_Conic:

if (point < limit)

{

FT_Vector vec;

FT_Vector v_middle;

point++;

tags++;

tag = FT_CURVE_TAG(tags[0]);

vec.x = point->x;

vec.y = point->y;

if (tag == FT_CURVE_TAG_ON)

{

double xctl = conv(v_control.x);

double yctl = flip_y ? -conv(v_control.y) : conv(v_control.y);

double xto = conv(vec.x);

double yto = flip_y ? -conv(vec.y) : conv(vec.y);

*(outpoints++) = xctl;

*(outpoints++) = yctl;

*(outpoints++) = xto;

*(outpoints++) = yto;

*(outcodes++) = CURVE3;

*(outcodes++) = CURVE3;

continue;

}

v_middle.x = (v_control.x + vec.x) / 2;

v_middle.y = (v_control.y + vec.y) / 2;

double xctl = conv(v_control.x);

double yctl = flip_y ? -conv(v_control.y) : conv(v_control.y);

double xto = conv(v_middle.x);

double yto = flip_y ? -conv(v_middle.y) : conv(v_middle.y);

*(outpoints++) = xctl;

*(outpoints++) = yctl;

*(outpoints++) = xto;

*(outpoints++) = yto;

*(outcodes++) = CURVE3;

*(outcodes++) = CURVE3;

v_control = vec;

goto Do_Conic;

}

double xctl = conv(v_control.x);

double yctl = flip_y ? -conv(v_control.y) : conv(v_control.y);

double xto = conv(v_start.x);

double yto = flip_y ? -conv(v_start.y) : conv(v_start.y);

*(outpoints++) = xctl;

*(outpoints++) = yctl;

*(outpoints++) = xto;

*(outpoints++) = yto;

*(outcodes++) = CURVE3;

*(outcodes++) = CURVE3;

goto Close;

}

default: // FT_CURVE_TAG_CUBIC

{

FT_Vector vec1, vec2;

vec1.x = point[0].x;

vec1.y = point[0].y;

vec2.x = point[1].x;

vec2.y = point[1].y;

point += 2;

tags += 2;

if (point <= limit)

{

FT_Vector vec;

vec.x = point->x;

vec.y = point->y;

double xctl1 = conv(vec1.x);

double yctl1 = flip_y ? -conv(vec1.y) : conv(vec1.y);

double xctl2 = conv(vec2.x);

double yctl2 = flip_y ? -conv(vec2.y) : conv(vec2.y);

double xto = conv(vec.x);

double yto = flip_y ? -conv(vec.y) : conv(vec.y);

(*outpoints++) = xctl1;

(*outpoints++) = yctl1;

(*outpoints++) = xctl2;

(*outpoints++) = yctl2;

(*outpoints++) = xto;

(*outpoints++) = yto;

(*outcodes++) = CURVE4;

(*outcodes++) = CURVE4;

(*outcodes++) = CURVE4;

continue;

}

double xctl1 = conv(vec1.x);

double yctl1 = flip_y ? -conv(vec1.y) : conv(vec1.y);

double xctl2 = conv(vec2.x);

double yctl2 = flip_y ? -conv(vec2.y) : conv(vec2.y);

double xto = conv(v_start.x);

double yto = flip_y ? -conv(v_start.y) : conv(v_start.y);

(*outpoints++) = xctl1;

(*outpoints++) = yctl1;

(*outpoints++) = xctl2;

(*outpoints++) = yctl2;

(*outpoints++) = xto;

(*outpoints++) = yto;

(*outcodes++) = CURVE4;

(*outcodes++) = CURVE4;

(*outcodes++) = CURVE4;

goto Close;

}

}

}

(*outpoints++) = 0.0;

(*outpoints++) = 0.0;

(*outcodes++) = ENDPOLY;

Close:

first = last + 1;

}

if (outcodes - (unsigned char *)PyArray_DATA(codes) != count) {

throw Py::RuntimeError("Font path size doesn't match");

}

return result;

Py::PythonClass<FT2Font>(self, args, kwds),

image()

{

FT_Open_Args open_args;

/* This string is only used for error messages, so encode it in something

std::string facefile = Py::String(args[0]).encode("unicode_escape");

args.verify_length(1);

clear(Py::Tuple(0));

memset(&stream, 0, sizeof(FT_StreamRec));

mem = NULL;

mem_size = 0;

if (make_open_args(args[0].ptr(), &open_args)) {

/* make_open_args sets the Python exception for us. */

throw Py::Exception();

}

int error = FT_Open_Face(_ft2Library, &open_args, 0, &face);

if (error == FT_Err_Unknown_File_Format)

{

std::ostringstream s;

s << "Could not load facefile " << facefile << "; Unknown_File_Format" << std::endl;

throw Py::RuntimeError(s.str());

}

else if (error == FT_Err_Cannot_Open_Resource)

{

std::ostringstream s;

s << "Could not open facefile " << facefile << "; Cannot_Open_Resource" << std::endl;

throw Py::RuntimeError(s.str());

}

else if (error == FT_Err_Invalid_File_Format)

{

std::ostringstream s;

s << "Could not open facefile " << facefile << "; Invalid_File_Format" << std::endl;

throw Py::RuntimeError(s.str());

}

else if (error)

{

std::ostringstream s;

s << "Could not open facefile " << facefile << "; freetype error code " << error << std::endl;

throw Py::RuntimeError(s.str());

}

// set a default fontsize 12 pt at 72dpi

hinting_factor = 8;

if (kwds.hasKey("hinting_factor"))

{

hinting_factor = Py::Long(kwds["hinting_factor"]);

}

error = FT_Set_Char_Size(face, 12 * 64, 0, 72 * hinting_factor, 72);

static FT_Matrix transform = { 65536 / hinting_factor, 0, 0, 65536 };

FT_Set_Transform(face, &transform, 0);

if (error)

{

std::ostringstream s;

s << "Could not set the fontsize for facefile " << facefile << std::endl;

throw Py::RuntimeError(s.str());

}

// set some face props as attributes

//small memory leak fixed after 2.1.8

//fields can be null so we have to check this first

const char* ps_name = FT_Get_Postscript_Name(face);

if (ps_name == NULL)

{

ps_name = "UNAVAILABLE";

}

const char* family_name = face->family_name;

if (family_name == NULL)

{

family_name = "UNAVAILABLE";

}

const char* style_name = face->style_name;

if (style_name == NULL)

{

style_name = "UNAVAILABLE";

}

setattro("postscript_name", Py::String(ps_name));

setattro("num_faces", Py::Int(face->num_faces));

setattro("family_name", Py::String(family_name));

setattro("style_name", Py::String(style_name));

setattro("face_flags", Py::Int(face->face_flags));

setattro("style_flags", Py::Int(face->style_flags));

setattro("num_glyphs", Py::Int(face->num_glyphs));

setattro("num_fixed_sizes", Py::Int(face->num_fixed_sizes));

setattro("num_charmaps", Py::Int(face->num_charmaps));

int scalable = FT_IS_SCALABLE(face);

setattro("scalable", Py::Int(scalable));

if (scalable)

{

setattro("units_per_EM", Py::Int(face->units_per_EM));

Py::Tuple bbox(4);

bbox[0] = Py::Int(face->bbox.xMin);

bbox[1] = Py::Int(face->bbox.yMin);

bbox[2] = Py::Int(face->bbox.xMax);

bbox[3] = Py::Int(face->bbox.yMax);

setattro("bbox", bbox);

setattro("ascender", Py::Int(face->ascender));

setattro("descender", Py::Int(face->descender));

setattro("height", Py::Int(face->height));

setattro("max_advance_width", Py::Int(face->max_advance_width));

setattro("max_advance_height", Py::Int(face->max_advance_height));

setattro("underline_position", Py::Int(face->underline_position));

setattro("underline_thickness", Py::Int(face->underline_thickness));

}

setattro("fname", args[0]);

_VERBOSE("FT2Font::FT2Font done");

{

_VERBOSE("FT2Font::setattr");

__dict__[name] = value;

return 1;

{