/*

SDL_ttf: A companion library to SDL for working with TrueType (tm) fonts

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Library General Public

License as published by the Free Software Foundation; either

version 2 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with this library; if not, write to the Free

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Sam Lantinga

slouken@libsdl.org

*/

/* $Id$ */

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#ifdef HAVE_ALLOCA

#define ALLOCA(n) ((void*)alloca(n))

#define FREEA(p)

#else

#define ALLOCA(n) malloc(n)

#define FREEA(p) free(p)

#endif

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_OUTLINE_H

#include FT_STROKER_H

#include FT_GLYPH_H

#include "SDL_ttf.h"

/* FIXME: Right now we assume the gray-scale renderer Freetype is using

supports 256 shades of gray, but we should instead key off of num_grays

in the result FT_Bitmap after the FT_Render_Glyph() call. */

#define NUM_GRAYS 256

/* Handy routines for converting from fixed point */

#define FT_FLOOR(X) ((X & -64) / 64)

#define FT_CEIL(X) (((X + 63) & -64) / 64)

#define CACHED_METRICS 0x10

#define CACHED_BITMAP 0x01

#define CACHED_PIXMAP 0x02

/* Cached glyph information */

typedef struct cached_glyph {

int stored;

FT_UInt index;

FT_Bitmap bitmap;

FT_Bitmap pixmap;

int minx;

int maxx;

int miny;

int maxy;

int yoffset;

int advance;

Uint16 cached;

} c_glyph;

/* The structure used to hold internal font information */

struct _TTF_Font {

/* Freetype2 maintains all sorts of useful info itself */

FT_Face face;

/* We'll cache these ourselves */

int height;

int ascent;

int descent;

int lineskip;

/* The font style */

/* Whether kerning is desired */

int kerning;

/* Extra width in glyph bounds for text styles */

int glyph_overhang;

float glyph_italics;

/* Information in the font for underlining */

int underline_offset;

int underline_height;

/* Cache for style-transformed glyphs */

c_glyph *current;

c_glyph cache[256];

c_glyph scratch;

/* We are responsible for closing the font stream */

SDL_RWops *src;

int freesrc;

FT_Open_Args args;

/* For non-scalable formats, we must remember which font index size */

int font_size_family;

/* really just flags passed into FT_Load_Glyph */

int hinting;

};

/* Handle a style only if the font does not already handle it */

#define TTF_HANDLE_STYLE_BOLD(font) (((font)->style & TTF_STYLE_BOLD) && \

!((font)->face_style & TTF_STYLE_BOLD))

#define TTF_HANDLE_STYLE_ITALIC(font) (((font)->style & TTF_STYLE_ITALIC) && \

!((font)->face_style & TTF_STYLE_ITALIC))

#define TTF_HANDLE_STYLE_UNDERLINE(font) ((font)->style & TTF_STYLE_UNDERLINE)

#define TTF_HANDLE_STYLE_STRIKETHROUGH(font) ((font)->style & TTF_STYLE_STRIKETHROUGH)

/* Font styles that does not impact glyph drawing */

#define TTF_STYLE_NO_GLYPH_CHANGE (TTF_STYLE_UNDERLINE | TTF_STYLE_STRIKETHROUGH)

/* The FreeType font engine/library */

static FT_Library library;

static int TTF_initialized = 0;

static int TTF_byteswapped = 0;

/* UNICODE string utilities */

static __inline__ int UNICODE_strlen(const Uint16 *text)

{

int size = 0;

while ( *text++ ) {

++size;

}

return size;

}

static __inline__ void UNICODE_strcpy(Uint16 *dst, const Uint16 *src, int swap)

{

if ( swap ) {

while ( *src ) {

*dst = SDL_Swap16(*src);

++src;

++dst;

}

*dst = '\0';

} else {

while ( *src ) {

*dst = *src;

++src;

++dst;

}

*dst = '\0';

}

}

/* Gets the top row of the underline. The outline

is taken into account.

*/

static __inline__ int TTF_underline_top_row(TTF_Font *font)

{

/* With outline, the underline_offset is underline_offset+outline. */

/* So, we don't have to remove the top part of the outline height. */

return font->ascent - font->underline_offset - 1;

}

/* Gets the bottom row of the underline. The outline

is taken into account.

*/

static __inline__ int TTF_underline_bottom_row(TTF_Font *font)

{

int row = TTF_underline_top_row(font) + font->underline_height;

if( font->outline > 0 ) {

/* Add underline_offset outline offset and */

/* the bottom part of the outline. */

row += font->outline * 2;

}

return row;

}

/* Gets the top row of the strikethrough. The outline

is taken into account.

*/

static __inline__ int TTF_strikethrough_top_row(TTF_Font *font)

{

/* With outline, the first text row is 'outline'. */

/* So, we don't have to remove the top part of the outline height. */

return font->height / 2;

}

/* Gets the bottom row of the strikethrough. The outline

is taken into account.

*/

static __inline__ int TTF_strikethrough_bottom_row(TTF_Font *font)

{

int row = TTF_strikethrough_top_row(font) + font->underline_height;

if( font->outline > 0 ) {

/* Add first text row outline offset and */

/* the bottom part of the outline. */

row += font->outline * 2;

}

return row;

}

static void TTF_initLineMectrics(const TTF_Font *font, const SDL_Surface *textbuf, const int row, Uint8 **pdst, int *pheight)

Uint8 *dst;

int height;

dst = (Uint8 *)textbuf->pixels;

if( row > 0 ) {

dst += row * textbuf->pitch;

}

height = font->underline_height;

/* Take outline into account */

if( font->outline > 0 ) {

height += font->outline * 2;

}

*pdst = dst;

*pheight = height;

}

/* Draw a solid line of underline_height (+ optional outline)

at the given row. The row value must take the

outline into account.

*/

static void TTF_drawLine_Solid(const TTF_Font *font, const SDL_Surface *textbuf, const int row)

{

int line;

Uint8 *dst_check = (Uint8*)textbuf->pixels + textbuf->pitch * textbuf->h;

Uint8 *dst;

int height;

TTF_initLineMectrics(font, textbuf, row, &dst, &height);

/* Draw line */

for ( line=height; line>0 && dst < dst_check; --line ) {

/* 1 because 0 is the bg color */

memset( dst, 1, textbuf->w );

dst += textbuf->pitch;

}

}

/* Draw a shaded line of underline_height (+ optional outline)

at the given row. The row value must take the

outline into account.

*/

static void TTF_drawLine_Shaded(const TTF_Font *font, const SDL_Surface *textbuf, const int row)

{

int line;

Uint8 *dst_check = (Uint8*)textbuf->pixels + textbuf->pitch * textbuf->h;

Uint8 *dst;

int height;

TTF_initLineMectrics(font, textbuf, row, &dst, &height);

/* Draw line */

for ( line=height; line>0 && dst < dst_check; --line ) {

memset( dst, NUM_GRAYS - 1, textbuf->w );

dst += textbuf->pitch;

}

}

/* Draw a blended line of underline_height (+ optional outline)

at the given row. The row value must take the

outline into account.

*/

static void TTF_drawLine_Blended(const TTF_Font *font, const SDL_Surface *textbuf, const int row, const Uint32 color)

{

int line;

Uint32 *dst_check = (Uint32*)textbuf->pixels + textbuf->pitch/4 * textbuf->h;

Uint8 *dst8; /* destination, byte version */

Uint32 *dst;

int height;

int col;

Uint32 pixel = color | 0xFF000000; /* Amask */

TTF_initLineMectrics(font, textbuf, row, &dst8, &height);

dst = (Uint32 *) dst8;

/* Draw line */

for ( line=height; line>0 && dst < dst_check; --line ) {

for ( col=0; col < textbuf->w; ++col ) {

dst[col] = pixel;

}

dst += textbuf->pitch/4;

}

}

/* rcg06192001 get linked library's version. */

const SDL_version *TTF_Linked_Version(void)

{

}

/* This function tells the library whether UNICODE text is generally

byteswapped. A UNICODE BOM character at the beginning of a string

will override this setting for that string.

*/

void TTF_ByteSwappedUNICODE(int swapped)

{

TTF_byteswapped = swapped;

}

static void TTF_SetFTError(const char *msg, FT_Error error)

{

#ifdef USE_FREETYPE_ERRORS

#undef FTERRORS_H

#define FT_ERRORDEF( e, v, s ) { e, s },

static const struct

{

int err_code;

const char* err_msg;

} ft_errors[] = {

#include <freetype/fterrors.h>

};

int i;

const char *err_msg;

char buffer[1024];

err_msg = NULL;

for ( i=0; i<((sizeof ft_errors)/(sizeof ft_errors[0])); ++i ) {

if ( error == ft_errors[i].err_code ) {

err_msg = ft_errors[i].err_msg;

break;

}

}

if ( ! err_msg ) {

err_msg = "unknown FreeType error";

}

sprintf(buffer, "%s: %s", msg, err_msg);

TTF_SetError(buffer);

#else

TTF_SetError(msg);

#endif /* USE_FREETYPE_ERRORS */

}

int TTF_Init( void )

{

if ( ! TTF_initialized ) {

FT_Error error = FT_Init_FreeType( &library );

if ( error ) {

TTF_SetFTError("Couldn't init FreeType engine", error);

status = -1;

}

}

if ( status == 0 ) {

++TTF_initialized;

}

return status;

}

static unsigned long RWread(

FT_Stream stream,

unsigned long offset,

unsigned char* buffer,

unsigned long count

)

{

SDL_RWops *src;

src = (SDL_RWops *)stream->descriptor.pointer;

SDL_RWseek( src, (int)offset, SEEK_SET );

if ( count == 0 ) {

return 0;

}

return SDL_RWread( src, buffer, 1, (int)count );

}

TTF_Font* TTF_OpenFontIndexRW( SDL_RWops *src, int freesrc, int ptsize, long index )

{

TTF_Font* font;

FT_Error error;

FT_Face face;

FT_Fixed scale;

FT_Stream stream;

int position;

if ( ! TTF_initialized ) {

TTF_SetError( "Library not initialized" );

return NULL;

}

/* Check to make sure we can seek in this stream */

position = SDL_RWtell(src);

if ( position < 0 ) {

TTF_SetError( "Can't seek in stream" );

return NULL;

}

font = (TTF_Font*) malloc(sizeof *font);

if ( font == NULL ) {

TTF_SetError( "Out of memory" );

return NULL;

}

font->src = src;

font->freesrc = freesrc;

stream = (FT_Stream)malloc(sizeof(*stream));

if ( stream == NULL ) {

TTF_SetError( "Out of memory" );

TTF_CloseFont( font );

return NULL;

}

memset(stream, 0, sizeof(*stream));

stream->read = RWread;

stream->descriptor.pointer = src;

stream->pos = (unsigned long)position;

SDL_RWseek(src, 0, SEEK_END);

stream->size = (unsigned long)(SDL_RWtell(src) - position);

SDL_RWseek(src, position, SEEK_SET);

font->args.stream = stream;

error = FT_Open_Face( library, &font->args, index, &font->face );

if( error ) {

TTF_SetFTError( "Couldn't load font file", error );

TTF_CloseFont( font );

return NULL;

face = font->face;

/* Make sure that our font face is scalable (global metrics) */

if ( FT_IS_SCALABLE(face) ) {

/* Set the character size and use default DPI (72) */

error = FT_Set_Char_Size( font->face, 0, ptsize * 64, 0, 0 );

if( error ) {

TTF_SetFTError( "Couldn't set font size", error );

TTF_CloseFont( font );

return NULL;

}

/* Get the scalable font metrics for this font */

scale = face->size->metrics.y_scale;

font->ascent = FT_CEIL(FT_MulFix(face->ascender, scale));

font->descent = FT_CEIL(FT_MulFix(face->descender, scale));

font->height = font->ascent - font->descent + /* baseline */ 1;

font->lineskip = FT_CEIL(FT_MulFix(face->height, scale));

font->underline_offset = FT_FLOOR(FT_MulFix(face->underline_position, scale));

font->underline_height = FT_FLOOR(FT_MulFix(face->underline_thickness, scale));

} else {

/* Non-scalable font case. ptsize determines which family

* or series of fonts to grab from the non-scalable format.

* It is not the point size of the font.

* */

if ( ptsize >= font->face->num_fixed_sizes )

ptsize = font->face->num_fixed_sizes - 1;

font->font_size_family = ptsize;

error = FT_Set_Pixel_Sizes( face,

face->available_sizes[ptsize].height,

face->available_sizes[ptsize].width );

/* With non-scalale fonts, Freetype2 likes to fill many of the

* font metrics with the value of 0. The size of the

* non-scalable fonts must be determined differently

* or sometimes cannot be determined.

* */

font->ascent = face->available_sizes[ptsize].height;

font->descent = 0;

font->height = face->available_sizes[ptsize].height;

font->lineskip = FT_CEIL(font->ascent);

font->underline_offset = FT_FLOOR(face->underline_position);

font->underline_height = FT_FLOOR(face->underline_thickness);

}

if ( font->underline_height < 1 ) {

font->underline_height = 1;

}

#ifdef DEBUG_FONTS

printf("Font metrics:\n");

printf("\tascent = %d, descent = %d\n",

font->ascent, font->descent);

printf("\theight = %d, lineskip = %d\n",

font->height, font->lineskip);

printf("\tunderline_offset = %d, underline_height = %d\n",

font->underline_offset, font->underline_height);

printf("\tunderline_top_row = %d, strikethrough_top_row = %d\n",

TTF_underline_top_row(font), TTF_strikethrough_top_row(font));

#endif

/* Initialize the font face style */

font->face_style = TTF_STYLE_NORMAL;

if ( font->face->style_flags & FT_STYLE_FLAG_BOLD ) {

font->face_style |= TTF_STYLE_BOLD;

}

if ( font->face->style_flags & FT_STYLE_FLAG_ITALIC ) {

font->face_style |= TTF_STYLE_ITALIC;

}

font->glyph_overhang = face->size->metrics.y_ppem / 10;

/* x offset = cos(((90.0-12)/360)*2*M_PI), or 12 degree angle */

font->glyph_italics = 0.207f;

font->glyph_italics *= font->height;

return font;

}

TTF_Font* TTF_OpenFontRW( SDL_RWops *src, int freesrc, int ptsize )

{

return TTF_OpenFontIndexRW(src, freesrc, ptsize, 0);

}

TTF_Font* TTF_OpenFontIndex( const char *file, int ptsize, long index )

{

TTF_SetError(SDL_GetError());

return NULL;

}

return TTF_OpenFontIndexRW(rw, 1, ptsize, index);

}

TTF_Font* TTF_OpenFont( const char *file, int ptsize )

{

}

static void Flush_Glyph( c_glyph* glyph )

{

glyph->stored = 0;

glyph->index = 0;

if( glyph->bitmap.buffer ) {

free( glyph->bitmap.buffer );

glyph->bitmap.buffer = 0;

}

if( glyph->pixmap.buffer ) {

free( glyph->pixmap.buffer );

glyph->pixmap.buffer = 0;

}

glyph->cached = 0;

}

static void Flush_Cache( TTF_Font* font )

{

int i;

int size = sizeof( font->cache ) / sizeof( font->cache[0] );

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

if( font->cache[i].cached ) {

Flush_Glyph( &font->cache[i] );

}

}

if( font->scratch.cached ) {

Flush_Glyph( &font->scratch );

}

}

static FT_Error Load_Glyph( TTF_Font* font, Uint16 ch, c_glyph* cached, int want )

{

FT_Face face;

FT_Error error;

FT_GlyphSlot glyph;

FT_Glyph_Metrics* metrics;

FT_Outline* outline;

if ( !font || !font->face ) {

return FT_Err_Invalid_Handle;

}

face = font->face;

/* Load the glyph */

if ( ! cached->index ) {

cached->index = FT_Get_Char_Index( face, ch );

}

if( error ) {

return error;

}

/* Get our glyph shortcuts */

glyph = face->glyph;

metrics = &glyph->metrics;

outline = &glyph->outline;

/* Get the glyph metrics if desired */

if ( (want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS) ) {

if ( FT_IS_SCALABLE( face ) ) {

/* Get the bounding box */

cached->minx = FT_FLOOR(metrics->horiBearingX);

cached->maxx = cached->minx + FT_CEIL(metrics->width);

cached->maxy = FT_FLOOR(metrics->horiBearingY);

cached->miny = cached->maxy - FT_CEIL(metrics->height);

cached->yoffset = font->ascent - cached->maxy;

cached->advance = FT_CEIL(metrics->horiAdvance);

} else {

/* Get the bounding box for non-scalable format.

* Again, freetype2 fills in many of the font metrics

* with the value of 0, so some of the values we

* need must be calculated differently with certain

* assumptions about non-scalable formats.

* */

cached->minx = FT_FLOOR(metrics->horiBearingX);

cached->maxx = cached->minx + FT_CEIL(metrics->horiAdvance);

cached->maxy = FT_FLOOR(metrics->horiBearingY);

cached->miny = cached->maxy - FT_CEIL(face->available_sizes[font->font_size_family].height);

cached->yoffset = 0;

cached->advance = FT_CEIL(metrics->horiAdvance);

}

cached->maxx += font->glyph_overhang;

}

cached->maxx += (int)ceil(font->glyph_italics);

}

cached->stored |= CACHED_METRICS;

}

if ( ((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP)) ||

((want & CACHED_PIXMAP) && !(cached->stored & CACHED_PIXMAP)) ) {

int mono = (want & CACHED_BITMAP);

int i;

FT_Bitmap* src;

FT_Bitmap* dst;

/* Handle the italic style */

FT_Matrix shear;

shear.xx = 1 << 16;

shear.xy = (int) ( font->glyph_italics * ( 1 << 16 ) ) / font->height;

shear.yx = 0;

shear.yy = 1 << 16;

FT_Outline_Transform( outline, &shear );

}

/* Render as outline */

if( (font->outline > 0) && glyph->format != FT_GLYPH_FORMAT_BITMAP ) {

FT_Stroker stroker;

FT_Get_Glyph( glyph, &bitmap_glyph );

error = FT_Stroker_New( library, &stroker );

if( error ) {

return error;

}

FT_Stroker_Set( stroker, font->outline * 64, FT_STROKER_LINECAP_ROUND, FT_STROKER_LINEJOIN_ROUND, 0 );

FT_Glyph_Stroke( &bitmap_glyph, stroker, 1 /* delete the original glyph */ );

FT_Stroker_Done( stroker );

/* Render the glyph */

error = FT_Glyph_To_Bitmap( &bitmap_glyph, mono ? ft_render_mode_mono : ft_render_mode_normal, 0, 1 );

if( error ) {

FT_Done_Glyph( bitmap_glyph );

return error;

}

src = &((FT_BitmapGlyph)bitmap_glyph)->bitmap;

/* Render the glyph */

error = FT_Render_Glyph( glyph, mono ? ft_render_mode_mono : ft_render_mode_normal );

if( error ) {

return error;

}

src = &glyph->bitmap;

}

/* Copy over information to cache */

if ( mono ) {

dst = &cached->bitmap;

} else {

dst = &cached->pixmap;

}

memcpy( dst, src, sizeof( *dst ) );

/* FT_Render_Glyph() and .fon fonts always generate a

* two-color (black and white) glyphslot surface, even

* when rendered in ft_render_mode_normal. */

/* FT_IS_SCALABLE() means that the font is in outline format,

* but does not imply that outline is rendered as 8-bit

* grayscale, because embedded bitmap/graymap is preferred

* (see FT_LOAD_DEFAULT section of FreeType2 API Reference).

* FT_Render_Glyph() canreturn two-color bitmap or 4/16/256-

* color graymap according to the format of embedded bitmap/

* graymap. */

}

/* Adjust for bold and italic text */

int bump = font->glyph_overhang;

dst->pitch += bump;

dst->width += bump;

}

int bump = (int)ceil(font->glyph_italics);

dst->pitch += bump;

dst->width += bump;

}

if( !dst->buffer ) {

return FT_Err_Out_Of_Memory;

}

memset( dst->buffer, 0, dst->pitch * dst->rows );

for( i = 0; i < src->rows; i++ ) {

int soffset = i * src->pitch;

int doffset = i * dst->pitch;

if ( mono ) {

unsigned char *srcp = src->buffer + soffset;

unsigned char *dstp = dst->buffer + doffset;

int j;

for ( j = 0; j < src->width; j += 8 ) {

unsigned char ch = *srcp++;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

ch <<= 1;

*dstp++ = (ch&0x80) >> 7;

}

for ( j = 0; j < src->width; j += 4 ) {

unsigned char ch = *srcp++;

*dstp++ = (((ch&0xA0) >> 6) >= 0x2) ? 1 : 0;

ch <<= 2;

*dstp++ = (((ch&0xA0) >> 6) >= 0x2) ? 1 : 0;

ch <<= 2;

*dstp++ = (((ch&0xA0) >> 6) >= 0x2) ? 1 : 0;

ch <<= 2;

*dstp++ = (((ch&0xA0) >> 6) >= 0x2) ? 1 : 0;

}

for ( j = 0; j < src->width; j += 2 ) {

unsigned char ch = *srcp++;

*dstp++ = (((ch&0xF0) >> 4) >= 0x8) ? 1 : 0;

ch <<= 4;

*dstp++ = (((ch&0xF0) >> 4) >= 0x8) ? 1 : 0;

}

} else {

for ( j = 0; j < src->width; j++ ) {

unsigned char ch = *srcp++;

*dstp++ = (ch >= 0x80) ? 1 : 0;

}

/* This special case wouldn't

* be here if the FT_Render_Glyph()

* function wasn't buggy when it tried

* to render a .fon font with 256

* shades of gray. Instead, it

* returns a black and white surface

* and we have to translate it back

* to a 256 gray shaded surface.

* */

unsigned char *srcp = src->buffer + soffset;

unsigned char *dstp = dst->buffer + doffset;

unsigned char ch;

int j, k;

for ( j = 0; j < src->width; j += 8) {

ch = *srcp++;

for (k = 0; k < 8; ++k) {

if ((ch&0x80) >> 7) {

*dstp++ = NUM_GRAYS - 1;

} else {

*dstp++ = 0x00;

}

ch <<= 1;

}

}

unsigned char *srcp = src->buffer + soffset;

unsigned char *dstp = dst->buffer + doffset;

unsigned char ch;

int j, k;

for ( j = 0; j < src->width; j += 4 ) {

ch = *srcp++;

for ( k = 0; k < 4; ++k ) {

if ((ch&0xA0) >> 6) {

*dstp++ = NUM_GRAYS * ((ch&0xA0) >> 6) / 3 - 1;

} else {

*dstp++ = 0x00;

}

ch <<= 2;

}

}

unsigned char *srcp = src->buffer + soffset;

unsigned char *dstp = dst->buffer + doffset;

unsigned char ch;

int j, k;

for ( j = 0; j < src->width; j += 2 ) {

ch = *srcp++;

for ( k = 0; k < 2; ++k ) {

if ((ch&0xF0) >> 4) {

*dstp++ = NUM_GRAYS * ((ch&0xF0) >> 4) / 15 - 1;

} else {

*dstp++ = 0x00;

}

ch <<= 4;

}

}

} else {

memcpy(dst->buffer+doffset,

src->buffer+soffset, src->pitch);

}

}

}

/* Handle the bold style */

int row;

int col;

int offset;

int pixel;

Uint8* pixmap;

/* The pixmap is a little hard, we have to add and clamp */

for( row = dst->rows - 1; row >= 0; --row ) {

pixmap = (Uint8*) dst->buffer + row * dst->pitch;

for( offset=1; offset <= font->glyph_overhang; ++offset ) {

for( col = dst->width - 1; col > 0; --col ) {

if( mono ) {

pixmap[col] |= pixmap[col-1];

} else {

pixel = (pixmap[col] + pixmap[col-1]);

if( pixel > NUM_GRAYS - 1 ) {

pixel = NUM_GRAYS - 1;

}

pixmap[col] = (Uint8) pixel;

}

}

}

}

}

/* Mark that we rendered this format */

if ( mono ) {

cached->stored |= CACHED_BITMAP;

} else {

cached->stored |= CACHED_PIXMAP;

}

/* Free outlined glyph */

if( bitmap_glyph ) {

FT_Done_Glyph( bitmap_glyph );

}

}

/* We're done, mark this glyph cached */

cached->cached = ch;

return 0;

}

static FT_Error Find_Glyph( TTF_Font* font, Uint16 ch, int want )

{

int retval = 0;

if( ch < 256 ) {

font->current = &font->cache[ch];

} else {

if ( font->scratch.cached != ch ) {

Flush_Glyph( &font->scratch );

}

font->current = &font->scratch;

}

if ( (font->current->stored & want) != want ) {

retval = Load_Glyph( font, ch, font->current, want );

}

return retval;

}

void TTF_CloseFont( TTF_Font* font )

{

if ( font ) {

Flush_Cache( font );

if ( font->face ) {

FT_Done_Face( font->face );

}

if ( font->args.stream ) {

free( font->args.stream );

}

if ( font->freesrc ) {

SDL_RWclose( font->src );

}

free( font );

}

{

int i;

for ( i=0; i < len; ++i ) {

unicode[i] = ((const unsigned char *)text)[i];

}

unicode[i] = 0;

return unicode;

}

static Uint16 *UTF8_to_UNICODE(Uint16 *unicode, const char *utf8, int len)

{

int i, j;

Uint16 ch;

for ( i=0, j=0; i < len; ++i, ++j ) {

ch = ((const unsigned char *)utf8)[i];

if ( ch >= 0xF0 ) {

ch = (Uint16)(utf8[i]&0x07) << 18;

ch |= (Uint16)(utf8[++i]&0x3F) << 12;

ch |= (Uint16)(utf8[++i]&0x3F) << 6;

ch |= (Uint16)(utf8[++i]&0x3F);

} else

if ( ch >= 0xE0 ) {

ch |= (Uint16)(utf8[++i]&0x3F) << 6;

ch |= (Uint16)(utf8[++i]&0x3F);

} else

if ( ch >= 0xC0 ) {

ch |= (Uint16)(utf8[++i]&0x3F);

}

unicode[j] = ch;

}

unicode[j] = 0;

return unicode;

}

{

return(font->height);

}

}

{

return(font->descent);

}

{

return(font->lineskip);

}

int TTF_GetFontKerning(const TTF_Font *font)

{

return(font->kerning);

}

void TTF_SetFontKerning(TTF_Font *font, int allowed)

{

font->kerning = allowed;

}

{

return(font->face->num_faces);

}