_isDirty(true),

_buffer(NULL),

_width(0), _height(0),

_rgbCopy(NULL),

_rgbaCopy(NULL) {

_VERBOSE("FT2Image::FT2Image");

resize(width, height);

size_t numBytes = width*height;

if (width != _width || height != _height) {

if (numBytes > _width*_height) {

delete [] _buffer;

_buffer = NULL;

_buffer = new unsigned char [numBytes];

}

_width = width;

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

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;

}

_isDirty = true;

FILE *fh = fopen(filename, "w");

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

}

fclose(fh);

_VERBOSE("FT2Image::write_bitmap");

args.verify_length(1);

std::string filename = Py::String(args[0]);

write_bitmap(filename.c_str());

return Py::Object();

unsigned long x1, unsigned long y1) {

if ( x0<0 || y0<0 || x1<0 || y1<0 ||

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 = CLAMP(x0, 0, _width);

y0 = CLAMP(y0, 0, _height);

x1 = CLAMP(x1, 0, _width);

y1 = CLAMP(y1, 0, _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

(PyString_FromStringAndSize((const char *)_buffer,

_width*_height)

);

if (!_isDirty)

return;

if (!_rgbCopy) {

_rgbCopy = new FT2Image(_width * 3, _height);

} else {

_rgbCopy->resize(_width * 3, _height);

}

unsigned char *src = _buffer;

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

unsigned char *dst = _rgbCopy->_buffer;

unsigned char tmp;

while (src != src_end) {

tmp = 255 - *src++;

*dst++ = tmp;

*dst++ = tmp;

*dst++ = tmp;

}

_VERBOSE("FT2Image::as_str_rgb");

args.verify_length(0);

makeRgbCopy();

return _rgbCopy->py_as_str(args);

if (!_isDirty)

return;

if (!_rgbaCopy) {

_rgbaCopy = new FT2Image(_width * 4, _height);

} else {

_rgbaCopy->resize(_width * 4, _height);

}

unsigned char *src = _buffer;

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

unsigned char *dst = _rgbaCopy->_buffer;

while (src != src_end) {

// We know the array has already been zero'ed out in

// the resize method, so we just skip over the r, g and b.

dst += 3;

*dst++ = *src++;

}

_VERBOSE("FT2Image::as_str_rgba");

args.verify_length(0);

makeRgbaCopy();

return _rgbaCopy->py_as_str(args);

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

glyphInd(ind) {

_VERBOSE("Glyph::Glyph");

FT_BBox bbox;

FT_Glyph_Get_CBox( glyph, ft_glyph_bbox_subpixels, &bbox );

setattr("width", Py::Int( face->glyph->metrics.width / HORIZ_HINTING) );

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

setattr("horiBearingX", Py::Int( face->glyph->metrics.horiBearingX / HORIZ_HINTING) );

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

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

setattr("linearHoriAdvance", Py::Int( face->glyph->linearHoriAdvance / HORIZ_HINTING) );

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

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

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

//setattr("bitmap_left", Py::Int( face->glyph->bitmap_left) );

//setattr("bitmap_top", Py::Int( face->glyph->bitmap_top) );

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

setattr("bbox", abbox);

setattr("path", get_path(face));

_VERBOSE("Glyph::setattr");

__dict__[name] = value;

return 0;

_VERBOSE("Glyph::getattr");

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

else return getattr_default( 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

enum {MOVETO, LINETO, CURVE3, CURVE4, ENDPOLY};

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

Py::List path;

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

first = 0;

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

{

int last; // index of last point in contour

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) return Py::Object();

// check first point to determine origin

if( tag == FT_CURVE_TAG_CONIC)

{

// first point is conic control. Yes, this happens.

if(FT_CURVE_TAG(outline.tags[last]) == FT_CURVE_TAG_ON)

{

// start at last point if it is on the curve

v_start = v_last;

limit--;

}

else

{

// if both first and last points are conic,

// start at their middle and record its position

// for closure

v_start.x = (v_start.x + v_last.x) / 2;

v_start.y = (v_start.y + v_last.y) / 2;

v_last = v_start;

}

point--;

tags--;

}

double x = conv(v_start.x);

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

Py::Tuple tup(3);

tup[0] = Py::Int(MOVETO);

tup[1] = Py::Float(x);

tup[2] = Py::Float(y);

path.append(tup);

Py::Tuple closepoly(2);

closepoly[0] = Py::Int(ENDPOLY);

closepoly[1] = Py::Int(0);

while(point < limit)

{

point++;

tags++;

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

Py::Tuple tup(3);

tup[0] = Py::Int(LINETO);

tup[1] = Py::Float(x);

tup[2] = Py::Float(y);

path.append(tup);

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

Py::Tuple tup(5);

tup[0] = Py::Int(CURVE3);

tup[1] = Py::Float(xctl);

tup[2] = Py::Float(yctl);

tup[3] = Py::Float(xto);

tup[4] = Py::Float(yto);

path.append(tup);

continue;

}

if(tag != FT_CURVE_TAG_CONIC) return Py::Object();

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

Py::Tuple tup(5);

tup[0] = Py::Int(CURVE3);

tup[1] = Py::Float(xctl);

tup[2] = Py::Float(yctl);

tup[3] = Py::Float(xto);

tup[4] = Py::Float(yto);

path.append(tup);

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

Py::Tuple tup(5);

tup[0] = Py::Int(CURVE3);

tup[1] = Py::Float(xctl);

tup[2] = Py::Float(yctl);

tup[3] = Py::Float(xto);

tup[4] = Py::Float(yto);

path.append(tup);

goto Close;

}

default: // FT_CURVE_TAG_CUBIC

{

FT_Vector vec1, vec2;

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

{

return Py::Object();

}

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

Py::Tuple tup(7);

tup[0] = Py::Int(CURVE4);

tup[1] = Py::Float(xctl1);

tup[2] = Py::Float(yctl1);

tup[3] = Py::Float(xctl2);

tup[4] = Py::Float(yctl2);

tup[5] = Py::Float(xto);

tup[6] = Py::Float(yto);

path.append(tup);

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

Py::Tuple tup(7);

tup[0] = Py::Int(CURVE4);

tup[1] = Py::Float(xctl1);

tup[2] = Py::Float(yctl1);

tup[3] = Py::Float(xctl2);

tup[4] = Py::Float(yctl2);

tup[5] = Py::Float(xto);

tup[6] = Py::Float(yto);

path.append(tup);

goto Close;

}

}

}

path.append(closepoly);

Close:

first = last + 1;

}

return path;

image(NULL)

{

_VERBOSE(Printf("FT2Font::FT2Font %s", facefile.c_str()).str());

clear(Py::Tuple(0));

int error = FT_New_Face( _ft2Library, facefile.c_str(), 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

#ifdef VERTICAL_HINTING

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

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

FT_Set_Transform( face, &transform, 0 );

#else

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

#endif

//error = FT_Set_Char_Size( face, 20 * 64, 0, 80, 80 );

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

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

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

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

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

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

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

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

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

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

int scalable = FT_IS_SCALABLE( face );

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

if (scalable) {

setattr("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);

setattr("bbox", bbox);

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

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

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

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

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

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

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

}

setattr("fname", Py::String(facefile));

_VERBOSE("FT2Font::FT2Font done");

_VERBOSE("FT2Font::setattr");

__dict__[name] = value;

return 1;

_VERBOSE("FT2Font::getattr");

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

else return getattr_default( name );

_VERBOSE("FT2Font::clear");

args.verify_length(0);

Py_XDECREF(image);

image = NULL;

angle = 0.0;

pen.x = 0;

pen.y = 0;

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

FT_Done_Glyph( glyphs[i] );

}

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

Py_DECREF(gms[i]);

}

glyphs.resize(0);

gms.resize(0);

return Py::Object();

_VERBOSE("FT2Font::set_size");

args.verify_length(2);

double ptsize = Py::Float(args[0]);

double dpi = Py::Float(args[1]);

#ifdef VERTICAL_HINTING

int error = FT_Set_Char_Size( face, (long)(ptsize * 64), 0,

(unsigned int)dpi * HORIZ_HINTING,

(unsigned int)dpi );

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

FT_Set_Transform( face, &transform, 0 );

#else

int error = FT_Set_Char_Size( face, (long)(ptsize * 64), 0,

(unsigned int)dpi,

(unsigned int)dpi );

#endif

if (error)

throw Py::RuntimeError("Could not set the fontsize");

return Py::Object();

_VERBOSE("FT2Font::set_charmap");

args.verify_length(1);

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

if (i>=face->num_charmaps)

throw Py::ValueError("i exceeds the available number of char maps");

FT_CharMap charmap = face->charmaps[i];

if (FT_Set_Charmap( face, charmap ))

throw Py::ValueError("Could not set the charmap");

return Py::Object();

_VERBOSE("FT2Font::compute_string_bbox");

FT_BBox bbox;

/* initialize string bbox to "empty" values */

bbox.xMin = bbox.yMin = 32000;

bbox.xMax = bbox.yMax = -32000;

for ( size_t n = 0; n < glyphs.size(); n++ ) {

FT_BBox glyph_bbox;

FT_Glyph_Get_CBox( glyphs[n], ft_glyph_bbox_subpixels, &glyph_bbox );

if ( glyph_bbox.xMin < bbox.xMin ) bbox.xMin = glyph_bbox.xMin;

if ( glyph_bbox.yMin < bbox.yMin ) bbox.yMin = glyph_bbox.yMin;

if ( glyph_bbox.xMax > bbox.xMax ) bbox.xMax = glyph_bbox.xMax;

if ( glyph_bbox.yMax > bbox.yMax ) bbox.yMax = glyph_bbox.yMax;

}

/* check that we really grew the string bbox */

if ( bbox.xMin > bbox.xMax ) {

bbox.xMin = 0; bbox.yMin = 0; bbox.xMax = 0; bbox.yMax = 0;

}

return bbox;

_VERBOSE("FT2Font::get_kerning");

args.verify_length(3);

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

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

int mode = Py::Int(args[2]);

if (!FT_HAS_KERNING( face )) return Py::Int(0);

FT_Vector delta;

if (!FT_Get_Kerning( face, left, right, mode, &delta )) {

return Py::Int(delta.x / HORIZ_HINTING);

}

else {

return Py::Int(0);

}

_VERBOSE("FT2Font::set_text");

args.verify_length(2);

Py::String text( args[0] );

std::string stdtext="";

Py_UNICODE* pcode=NULL;

size_t N = 0;

if (PyUnicode_Check(text.ptr())) {

pcode = PyUnicode_AsUnicode(text.ptr());

N = PyUnicode_GetSize(text.ptr());

}

else {

stdtext = text.as_std_string();

N = stdtext.size();

}

angle = Py::Float(args[1]);

angle = angle/360.0*2*3.14159;

long flags = FT_LOAD_FORCE_AUTOHINT;

if (kwargs.hasKey("flags"))

flags = Py::Long(kwargs["flags"]);

//this computes width and height in subpixels so we have to divide by 64

matrix.xx = (FT_Fixed)( cos( angle ) * 0x10000L );

matrix.xy = (FT_Fixed)(-sin( angle ) * 0x10000L );

matrix.yx = (FT_Fixed)( sin( angle ) * 0x10000L );

matrix.yy = (FT_Fixed)( cos( angle ) * 0x10000L );

FT_Bool use_kerning = FT_HAS_KERNING( face );

FT_UInt previous = 0;

glyphs.resize(0);

pen.x = 0;

pen.y = 0;

Py::Tuple xys(N);

for ( unsigned int n = 0; n < N; n++ ) {

std::string thischar("?");

FT_UInt glyph_index;

if (pcode==NULL) {

// plain ol string

thischar = stdtext[n];

glyph_index = FT_Get_Char_Index( face, stdtext[n] );

}

else {

//unicode

glyph_index = FT_Get_Char_Index( face, pcode[n] );

}

// retrieve kerning distance and move pen position

if ( use_kerning && previous && glyph_index ) {

FT_Vector delta;

FT_Get_Kerning( face, previous, glyph_index,

FT_KERNING_DEFAULT, &delta );

pen.x += delta.x / HORIZ_HINTING;

}

error = FT_Load_Glyph( face, glyph_index, flags );

if ( error ) {

std::cerr << "\tcould not load glyph for " << thischar << std::endl;

continue;

}

// ignore errors, jump to next glyph

// extract glyph image and store it in our table

FT_Glyph thisGlyph;

error = FT_Get_Glyph( face->glyph, &thisGlyph );

if ( error ) {

std::cerr << "\tcould not get glyph for " << thischar << std::endl;

continue;