_isDirty(true),

_buffer(NULL),

_width(0), _height(0),

_rgbCopy(NULL),

_rgbaCopy(NULL)

{

_VERBOSE("FT2Image::FT2Image");

resize(width, height);

{

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

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 > _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

(PyString_FromStringAndSize((const char *)_buffer,

_width*_height)

);

{

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

{

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;

ob_refcnt--;

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;

ob_refcnt--;

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;

ob_refcnt--;

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

}

else if (error)

{

std::ostringstream s;

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

ob_refcnt--;

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;

ob_refcnt--;

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

}

glyphs.clear();

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::set_charmap");

args.verify_length(1);

unsigned long i = Py::Long(args[0]);

//if (FT_Select_Charmap( face, FT_ENCODING_ADOBE_CUSTOM ))

if (FT_Select_Charmap(face, (FT_Encoding) i))

{

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;