/********************************************/

/* gd interface to freetype library         */

/*                                          */

/* John Ellson   ellson@graphviz.org        */

/********************************************/

/**

 * File: FreeType font rendering

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gd.h"

#include "gdhelpers.h"

#include "gd_intern.h"

/* 2.0.10: WIN32, not MSWIN32 */

#if !defined(_WIN32) && !defined(_WIN32_WCE)

#include <unistd.h>

#elif defined(_WIN32_WCE)

#include <wce_stdlib.h> /* getenv() */

#include <wce_unistd.h> /* access() */

#define getenv wceex_getenv

#define access wceex_access

#else /* _WIN32_WCE */

#include <io.h>

#ifndef R_OK

#define R_OK 04			/* Needed in Windows */

#endif

#endif

/* number of antialised colors for indexed bitmaps */

#define GD_NUMCOLORS 8

#ifdef HAVE_LIBFONTCONFIG

static int fontConfigFlag = 0;

/* translate a fontconfig fontpattern into a fontpath.

	return NULL if OK, else return error string */

static char *font_pattern(char **fontpath, char *fontpattern);

#endif

#ifdef HAVE_LIBFREETYPE

#include "entities.h"

static char *font_path(char **fontpath, char *name_list);

#endif

/* 2.0.30: move these up here so we can build correctly without freetype

	but with fontconfig */

/*

 * The character (space) used to separate alternate fonts in the

 * fontlist parameter to gdImageStringFT. 2.0.18: space was a

 * poor choice for this.

 */

#define LISTSEPARATOR ";"

/*

 * DEFAULT_FONTPATH and PATHSEPARATOR are host type dependent and

 * are normally set by configure in config.h.  These are just

 * some last resort values that might match some Un*x system

 * if building this version of gd separate from graphviz.

 */

#ifndef DEFAULT_FONTPATH

#  ifdef NETWARE

#    define DEFAULT_FONTPATH "sys:/java/nwgfx/lib/x11/fonts/ttf;."

#  elif defined(_WIN32)

#    define DEFAULT_FONTPATH "C:\\WINDOWS\\FONTS;C:\\WINNT\\FONTS"

#  elif defined(__APPLE__) || (defined(__MWERKS__) && defined(macintosh))

#    define DEFAULT_FONTPATH "/usr/share/fonts/truetype:/System/Library/Fonts:/Library/Fonts"

#  else

   /* default fontpath for unix systems  - whatever happened to standards ! */

#    define DEFAULT_FONTPATH "/usr/X11R6/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/truetype:/usr/X11R6/lib/X11/fonts/TTF:/usr/share/fonts/TrueType:/usr/share/fonts/truetype:/usr/openwin/lib/X11/fonts/TrueType:/usr/X11R6/lib/X11/fonts/Type1:/usr/lib/X11/fonts/Type1:/usr/openwin/lib/X11/fonts/Type1"

#  endif

#endif

#ifndef PATHSEPARATOR

#  if defined(NETWARE) || defined(_WIN32)

#    define PATHSEPARATOR ";"

#  else

#    define PATHSEPARATOR ":"

#  endif

#endif

#ifndef TRUE

#define FALSE 0

#define TRUE !FALSE

#endif

/**

 * Function: gdImageStringTTF

 *

 * Alias of <gdImageStringFT>.

 */

BGD_DECLARE(char *) gdImageStringTTF (gdImage * im, int *brect, int fg, char *fontlist,

                                      double ptsize, double angle, int x, int y, char *string)

{

	/* 2.0.6: valid return */

	return gdImageStringFT (im, brect, fg, fontlist, ptsize,

	                        angle, x, y, string);

}

#ifndef HAVE_LIBFREETYPE

BGD_DECLARE(char *) gdImageStringFTEx (gdImage * im, int *brect, int fg, char *fontlist,

                                       double ptsize, double angle, int x, int y, char *string,

                                       gdFTStringExtraPtr strex)

{

	(void)im;

	(void)brect;

	(void)fg;

	(void)fontlist;

	(void)ptsize;

	(void)angle;

	(void)x;

	(void)y;

	(void)string;

	(void)strex;

	return "libgd was not built with FreeType font support\n";

}

BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,

                                     double ptsize, double angle, int x, int y, char *string)

{

	(void)im;

	(void)brect;

	(void)fg;

	(void)fontlist;

	(void)ptsize;

	(void)angle;

	(void)x;

	(void)y;

	(void)string;

	return "libgd was not built with FreeType font support\n";

}

#else

#include "gdcache.h"

/* 2.0.16 Christophe Thomas: starting with FreeType 2.1.6, this is

  mandatory, and it has been supported for a long while. */

#ifdef HAVE_FT2BUILD_H

#include <ft2build.h>

#include FT_FREETYPE_H

#include FT_GLYPH_H

#include FT_SIZES_H

#else

#include <freetype/freetype.h>

#include <freetype/ftglyph.h>

#include <freetype/ftsizes.h>

#endif

/* number of fonts cached before least recently used is replaced */

#define FONTCACHESIZE 6

/* number of antialias color lookups cached */

#define TWEENCOLORCACHESIZE 32

/*

 * Line separation as a factor of font height.

 *      No space between if LINESPACE = 1.00

 *      Line separation will be rounded up to next pixel row.

 */

#define LINESPACE 1.05

typedef struct {

	char *fontlist;		/* key */

	int flags;			/* key */

	char *fontpath;

	FT_Library *library;

	FT_Face face;

}

font_t;

typedef struct {

	char *fontlist;		/* key */

	int flags;			/* key */

	FT_Library *library;

}

fontkey_t;

typedef struct {

	int pixel;			/* key */

	int bgcolor;			/* key */

	int fgcolor;			/* key *//* -ve means no antialias */

	gdImagePtr im;		/* key */

	int tweencolor;

}

tweencolor_t;

typedef struct {

	int pixel;			/* key */

	int bgcolor;			/* key */

	int fgcolor;			/* key *//* -ve means no antialias */

	gdImagePtr im;		/* key */

}

tweencolorkey_t;

/********************************************************************

 * gdTcl_UtfToUniChar is borrowed from Tcl ...

 */

/*

 * tclUtf.c --

 *

 *      Routines for manipulating UTF-8 strings.

 *

 * Copyright (c) 1997-1998 Sun Microsystems, Inc.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * SCCS: @(#) tclUtf.c 1.25 98/01/28 18:02:43

 */

/*

 *---------------------------------------------------------------------------

 *

 * gdTcl_UtfToUniChar --

 *

 *      Extract the Tcl_UniChar represented by the UTF-8 string.  Bad

 *      UTF-8 sequences are converted to valid Tcl_UniChars and processing

 *      continues.  Equivalent to Plan 9 chartorune().

 *

 *      The caller must ensure that the source buffer is long enough that

 *      this routine does not run off the end and dereference non-existent

 *      memory looking for trail bytes.  If the source buffer is known to

 *      be '\0' terminated, this cannot happen.  Otherwise, the caller

 *      should call Tcl_UtfCharComplete() before calling this routine to

 *      ensure that enough bytes remain in the string.

 *

 * Results:

 *      *chPtr is filled with the Tcl_UniChar, and the return value is the

 *      number of bytes from the UTF-8 string that were consumed.

 *

 * Side effects:

 *      None.

 *

 *---------------------------------------------------------------------------

 */

#ifdef JISX0208

#include "jisx0208.h"

#endif

static int comp_entities(const void *e1, const void *e2)

{

	struct entities_s *en1 = (struct entities_s *) e1;

	struct entities_s *en2 = (struct entities_s *) e2;

	return strcmp(en1->name, en2->name);

}

extern int any2eucjp (char *, char *, unsigned int);

/* Persistent font cache until explicitly cleared */

/* Fonts can be used across multiple images */

/* 2.0.16: thread safety (the font cache is shared) */

gdMutexDeclare (gdFontCacheMutex);

static gdCache_head_t *fontCache;

static FT_Library library;

#define Tcl_UniChar int

#define TCL_UTF_MAX 3

static int

gdTcl_UtfToUniChar (char *str, Tcl_UniChar * chPtr)

/* str is the UTF8 next character pointer */

/* chPtr is the int for the result */

{

	int byte;

	char entity_name_buf[ENTITY_NAME_LENGTH_MAX+1];

	char *p;

	struct entities_s key, *res;

	/* HTML4.0 entities in decimal form, e.g. Å */

	/*           or in hexadecimal form, e.g. 水 */

	byte = *((unsigned char *) str);

	if (byte == '&') {

		int i, n = 0;

		byte = *((unsigned char *) (str + 1));

		if (byte == '#') {

			byte = *((unsigned char *) (str + 2));

			if (byte == 'x' || byte == 'X') {

				for (i = 3; i < 8; i++) {

					byte = *((unsigned char *) (str + i));

					if (byte >= 'A' && byte <= 'F')

						byte = byte - 'A' + 10;

					else if (byte >= 'a' && byte <= 'f')

						byte = byte - 'a' + 10;

					else if (byte >= '0' && byte <= '9')

						byte = byte - '0';

					else

						break;

					n = (n * 16) + byte;

				}

			} else {

				for (i = 2; i < 8; i++) {

					byte = *((unsigned char *) (str + i));

					if (byte >= '0' && byte <= '9')

						n = (n * 10) + (byte - '0');

					else

						break;

				}

			}

			if (byte == ';') {

				*chPtr = (Tcl_UniChar) n;

				return ++i;

			}

		} else {

			key.name = p = entity_name_buf;

			for (i = 1; i <= 1 + ENTITY_NAME_LENGTH_MAX; i++) {

				byte = *((unsigned char *) (str + i));

				if (byte == '\0')

					break;

				if (byte == ';') {

					*p++ = '\0';

					res = bsearch(&key, entities, NR_OF_ENTITIES,

					              sizeof(entities[0]), *comp_entities);

					if (res) {

						*chPtr = (Tcl_UniChar) res->value;

						return ++i;

					}

					break;

				}

				*p++ = byte;

			}

		}

	}

	/*

	 * Unroll 1 to 3 byte UTF-8 sequences, use loop to handle longer ones.

	 */

	byte = *((unsigned char *) str);

#ifdef JISX0208

	if (0xA1 <= byte && byte <= 0xFE) {

		int ku, ten;

		ku = (byte & 0x7F) - 0x20;

		ten = (str[1] & 0x7F) - 0x20;

		if ((ku < 1 || ku > 92) || (ten < 1 || ten > 94)) {

			*chPtr = (Tcl_UniChar) byte;

			return 1;

		}

		*chPtr = (Tcl_UniChar) UnicodeTbl[ku - 1][ten - 1];

		return 2;

	} else

#endif /* JISX0208 */

		if (byte < 0xC0) {

			/*

			 * Handles properly formed UTF-8 characters between

			 * 0x01 and 0x7F.  Also treats \0 and naked trail

			 * bytes 0x80 to 0xBF as valid characters representing

			 * themselves.

			 */

			*chPtr = (Tcl_UniChar) byte;

			return 1;

		} else if (byte < 0xE0) {

			if ((str[1] & 0xC0) == 0x80) {

				/*

				 * Two-byte-character lead-byte followed

				 * by a trail-byte.

				 */

				*chPtr = (Tcl_UniChar) (((byte & 0x1F) << 6) | (str[1] & 0x3F));

				return 2;

			}

			/*

			 * A two-byte-character lead-byte not followed by trail-byte

			 * represents itself.

			 */

			*chPtr = (Tcl_UniChar) byte;

			return 1;

		} else if (byte < 0xF0) {

			if (((str[1] & 0xC0) == 0x80) && ((str[2] & 0xC0) == 0x80)) {

				/*

				 * Three-byte-character lead byte followed by

				 * two trail bytes.

				 */

				*chPtr = (Tcl_UniChar) (((byte & 0x0F) << 12)

				                        | ((str[1] & 0x3F) << 6) | (str[2] & 0x3F));

				return 3;

			}

			/*

			 * A three-byte-character lead-byte not followed by

			 * two trail-bytes represents itself.

			 */

			*chPtr = (Tcl_UniChar) byte;

			return 1;

		}

#if TCL_UTF_MAX > 3

		else {

			int ch, total, trail;

			total = totalBytes[byte];

			trail = total - 1;

			if (trail > 0) {

				ch = byte & (0x3F >> trail);

				do {

					str++;

					if ((*str & 0xC0) != 0x80) {

						*chPtr = byte;

						return 1;

					}

					ch <<= 6;

					ch |= (*str & 0x3F);

					trail--;

				} while (trail > 0);

				*chPtr = ch;

				return total;

			}

		}

#endif

	*chPtr = (Tcl_UniChar) byte;

	return 1;

}

/********************************************************************/

/* font cache functions                                             */

static int

fontTest (void *element, void *key)

{

	font_t *a = (font_t *) element;

	fontkey_t *b = (fontkey_t *) key;

	return (strcmp (a->fontlist, b->fontlist) == 0 && a->flags == b->flags);

}

#ifdef HAVE_LIBFONTCONFIG

static int useFontConfig(int flag)

{

	if (fontConfigFlag) {

		return (!(flag & gdFTEX_FONTPATHNAME));

	}

	return flag & gdFTEX_FONTCONFIG;

}

#endif

static void *

fontFetch (char **error, void *key)

{

	font_t *a;

	fontkey_t *b = (fontkey_t *) key;

	char *suffix;

	FT_Error err;

	const unsigned int b_font_list_len = strlen(b->fontlist);

	*error = NULL;

	a = (font_t *) gdMalloc (sizeof (font_t));

	if (!a) {

		return NULL;

	}

	a->fontlist = (char *) gdMalloc(b_font_list_len + 1);

	if (a->fontlist == NULL) {

		gdFree(a);

		return "could not alloc full list of fonts";

	}

	strncpy(a->fontlist, b->fontlist, b_font_list_len);

	a->fontlist[b_font_list_len] = 0;

	a->flags = b->flags;

	a->library = b->library;

	a->fontpath = NULL;

#ifdef HAVE_LIBFONTCONFIG

	if (!useFontConfig(b->flags))

		*error = font_path(&(a->fontpath), a->fontlist);

	else

		*error = font_pattern(&(a->fontpath), a->fontlist);

#else

	*error = font_path(&(a->fontpath), a->fontlist);

#endif /* HAVE_LIBFONTCONFIG */

	if (*error || !a->fontpath || !a->fontpath[0]) {

		gdFree(a->fontlist);

		if (a->fontpath)

			free(a->fontpath);

		gdFree(a);

		if (!*error)

			*error = "font_path() returned an empty font pathname";

		return NULL;

	}

	err = FT_New_Face(*b->library, a->fontpath, 0, &a->face);

	/* Read kerning metrics for Postscript fonts. */

	if (!err

	        && ((suffix = strstr(a->fontpath, ".pfa"))

	            || (suffix = strstr(a->fontpath, ".pfb")))

	        && ((strcpy(suffix, ".afm") && (access(a->fontpath, R_OK) == 0))

	            || (strcpy(suffix, ".pfm") && (access(a->fontpath, R_OK) == 0)))) {

		err = FT_Attach_File(a->face, a->fontpath);

	}

	if (err) {

		gdFree (a->fontlist);

		free(a->fontpath);

		gdFree(a);

		*error = "Could not read font";

		return NULL;

	}

	return (void *) a;

}

static void

fontRelease (void *element)

{

	font_t *a = (font_t *) element;

	FT_Done_Face (a->face);

	gdFree (a->fontlist);

	gdFree (a->fontpath);

	gdFree ((char *) element);

}

/********************************************************************/

/* tweencolor cache functions                                            */

static int

tweenColorTest (void *element, void *key)

{

	tweencolor_t *a = (tweencolor_t *) element;

	tweencolorkey_t *b = (tweencolorkey_t *) key;

	return (a->pixel == b->pixel

	        && a->bgcolor == b->bgcolor

	        && a->fgcolor == b->fgcolor && a->im == b->im);

}

/*

 * Computes a color in im's color table that is part way between

 * the background and foreground colors proportional to the gray

 * pixel value in the range 0-GD_NUMCOLORS. The fg and bg colors must already

 * be in the color table for palette images. For truecolor images the

 * returned value simply has an alpha component and gdImageAlphaBlend

 * does the work so that text can be alpha blended across a complex

 * background (TBB; and for real in 2.0.2).

 */

static void *

tweenColorFetch (char **error, void *key)

{

	tweencolor_t *a;

	tweencolorkey_t *b = (tweencolorkey_t *) key;

	int pixel, npixel, bg, fg;

	gdImagePtr im;

	(void)error;

	a = (tweencolor_t *) gdMalloc (sizeof (tweencolor_t));

	if (!a) {

		return NULL;

	}

	pixel = a->pixel = b->pixel;

	bg = a->bgcolor = b->bgcolor;

	fg = a->fgcolor = b->fgcolor;

	im = a->im = b->im;

	/* if fg is specified by a negative color idx, then don't antialias */

	if (fg < 0) {

		if ((pixel + pixel) >= GD_NUMCOLORS)

			a->tweencolor = -fg;

		else

			a->tweencolor = bg;

	} else {

		npixel = GD_NUMCOLORS - pixel;

		if (im->trueColor) {

			/* 2.0.1: use gdImageSetPixel to do the alpha blending work,

			   or to just store the alpha level. All we have to do here

			   is incorporate our knowledge of the percentage of this

			   pixel that is really "lit" by pushing the alpha value

			   up toward transparency in edge regions. */

			a->tweencolor = gdTrueColorAlpha (gdTrueColorGetRed (fg),

			                                  gdTrueColorGetGreen (fg),

			                                  gdTrueColorGetBlue (fg),

			                                  gdAlphaMax -

			                                  (gdTrueColorGetAlpha (fg) *

			                                   pixel / GD_NUMCOLORS));

		} else {

			a->tweencolor = gdImageColorResolve (im,

			                                     (pixel * im->red[fg] +

			                                      npixel * im->red[bg]) /

			                                     GD_NUMCOLORS,

			                                     (pixel * im->green[fg] +

			                                      npixel * im->green[bg]) /

			                                     GD_NUMCOLORS,

			                                     (pixel * im->blue[fg] +

			                                      npixel * im->blue[bg]) /

			                                     GD_NUMCOLORS);

		}

	}

	return (void *) a;

}

static void

tweenColorRelease (void *element)

{

	gdFree ((char *) element);

}

/* draw_bitmap - transfers glyph bitmap to GD image */

static char *

gdft_draw_bitmap (gdCache_head_t * tc_cache, gdImage * im, int fg,

                  FT_Bitmap bitmap, int pen_x, int pen_y)

{

	unsigned char *pixel = NULL;

	int *tpixel = NULL;

	int opixel;

	int x, y, row, col, pc, pcr;

	tweencolor_t *tc_elem;

	tweencolorkey_t tc_key;

	/* copy to image, mapping colors */

	tc_key.fgcolor = fg;

	tc_key.im = im;

	/* Truecolor version; does not require the cache */

	if (im->trueColor) {

		for (row = 0; row < bitmap.rows; row++) {

			pc = row * bitmap.pitch;

			pcr = pc;

			y = pen_y + row;

			/* clip if out of bounds */

			/* 2.0.16: clipping rectangle, not image bounds */

			if ((y > im->cy2) || (y < im->cy1))

				continue;

			for (col = 0; col < bitmap.width; col++, pc++) {

				int level;

				if (bitmap.pixel_mode == ft_pixel_mode_grays) {

					/*

					 * Scale to 128 levels of alpha for gd use.

					 * alpha 0 is opacity, so be sure to invert at the end

					 */

					level = (bitmap.buffer[pc] * gdAlphaMax /

					         (bitmap.num_grays - 1));

				} else if (bitmap.pixel_mode == ft_pixel_mode_mono) {

					/* 2.0.5: mode_mono fix from Giuliano Pochini */

					level =

					    ((bitmap.

					      buffer[(col >> 3) +

					             pcr]) & (1 << (~col & 0x07))) ?

					    gdAlphaTransparent : gdAlphaOpaque;

				} else {

					return "Unsupported ft_pixel_mode";

				}

				if (level == 0)  /* if background */

					continue;

				if ((fg >= 0) && (im->trueColor)) {

					/* Consider alpha in the foreground color itself to be an

					   upper bound on how opaque things get, when truecolor is

					   available. Without truecolor this results in far too many

					   color indexes. */

					level =

					    level * (gdAlphaMax -

					             gdTrueColorGetAlpha (fg)) / gdAlphaMax;

				}

				level = gdAlphaMax - level;   /* inverting to get alpha */

				x = pen_x + col;

				/* clip if out of bounds */

				/* 2.0.16: clip to clipping rectangle, Matt McNabb */

				if ((x > im->cx2) || (x < im->cx1))

					continue;

				/* get pixel location in gd buffer */

				tpixel = &im->tpixels[y][x];

				if (fg < 0) {

					if (level < (gdAlphaMax / 2)) {

						*tpixel = -fg;

					}

				} else {

					if (im->alphaBlendingFlag) {

						opixel = *tpixel;

						if (gdTrueColorGetAlpha(opixel) != gdAlphaTransparent) {

							*tpixel = gdAlphaBlend (opixel,

							                        (level << 24) + (fg & 0xFFFFFF));

						} else {

							*tpixel = (level << 24) + (fg & 0xFFFFFF);

						}

					} else {

						*tpixel = (level << 24) + (fg & 0xFFFFFF);

					}

				}

			}

		}

		return (char *) NULL;

	}

	/* Non-truecolor case, restored to its more or less original form */

	for (row = 0; row < bitmap.rows; row++) {

		int pcr;

		pc = row * bitmap.pitch;

		pcr = pc;

		if (bitmap.pixel_mode == ft_pixel_mode_mono)

			pc *= 8;		/* pc is measured in bits for monochrome images */

		y = pen_y + row;

		/* clip if out of bounds */

		if (y > im->cy2 || y < im->cy1)

			continue;

		for (col = 0; col < bitmap.width; col++, pc++) {

			if (bitmap.pixel_mode == ft_pixel_mode_grays) {

				/*

				 * Round to GD_NUMCOLORS levels of antialiasing for

				 * index color images since only 256 colors are

				 * available.

				 */

				tc_key.pixel = ((bitmap.buffer[pc] * GD_NUMCOLORS)

				                + bitmap.num_grays / 2)

				               / (bitmap.num_grays - 1);

			} else if (bitmap.pixel_mode == ft_pixel_mode_mono) {

				/* 2.0.5: mode_mono fix from Giuliano Pochini */

				tc_key.pixel =

				    ((bitmap.

				      buffer[(col >> 3) +

				             pcr]) & (1 << (~col & 0x07))) ? GD_NUMCOLORS : 0;

			} else {

				return "Unsupported ft_pixel_mode";

			}

			if (tc_key.pixel == 0)	/* if background */

				continue;

			x = pen_x + col;

			/* clip if out of bounds */

			if (x > im->cx2 || x < im->cx1)

				continue;

			/* get pixel location in gd buffer */

			pixel = &im->pixels[y][x];

			if (tc_key.pixel == GD_NUMCOLORS) {

				/* use fg color directly. gd 2.0.2: watch out for

				   negative indexes (thanks to David Marwood). */

				*pixel = (fg < 0) ? -fg : fg;

			} else {

				/* find antialised color */

				tc_key.bgcolor = *pixel;

				tc_elem = (tweencolor_t *) gdCacheGet (tc_cache, &tc_key);

				if (!tc_elem) return tc_cache->error;

				*pixel = tc_elem->tweencolor;

			}

		}

	}

	return (char *) NULL;

}

/**

 * Function: gdFreeFontCache

 *

 * Alias of <gdFontCacheShutdown>.

 */

BGD_DECLARE(void) gdFreeFontCache ()

{

	gdFontCacheShutdown ();

}

/**

 * Function: gdFontCacheShutdown

 *

 * Shut down the font cache and free the allocated resources.

 *

 * Important:

 *  This function has to be called whenever FreeType operations have been

 *  invoked, to avoid resource leaks. It doesn't harm to call this function

 *  multiple times.

 */

BGD_DECLARE(void) gdFontCacheShutdown ()

{

	if (fontCache) {

		gdMutexLock(gdFontCacheMutex);

		gdCacheDelete (fontCache);

		/* 2.0.16: Gustavo Scotti: make sure we don't free this twice */

		fontCache = 0;

		gdMutexUnlock(gdFontCacheMutex);

		gdMutexShutdown (gdFontCacheMutex);

		FT_Done_FreeType (library);

	}

}

/**

 * Function: gdImageStringFT

 *

 * Render an UTF-8 string onto a gd image.

 *

 * Parameters:

 *	im       - The image to draw onto.

 *  brect    - The bounding rectangle as array of 8 integers where each pair

 *             represents the x- and y-coordinate of a point. The points

 *             specify the lower left, lower right, upper right and upper left

 *             corner.

 *	fg       - The font color.

 *	fontlist - The semicolon delimited list of font filenames to look for.

 *	ptsize   - The height of the font in typographical points (pt).

 *	angle    - The angle in radian to rotate the font counter-clockwise.

 *	x        - The x-coordinate of the basepoint (roughly the lower left corner) of the first letter.

 *	y        - The y-coordinate of the basepoint (roughly the lower left corner) of the first letter.

 *	string   - The string to render.

 *

 * Variant:

 *  - <gdImageStringFTEx>

 *

 * See also:

 *  - <gdImageString>

 */

BGD_DECLARE(char *) gdImageStringFT (gdImage * im, int *brect, int fg, char *fontlist,

                                     double ptsize, double angle, int x, int y, char *string)

{

	return gdImageStringFTEx (im, brect, fg, fontlist,

	                          ptsize, angle, x, y, string, 0);

}

/**

 * Function: gdFontCacheSetup

 *

 * Set up the font cache.

 *

 * This is called automatically from the string rendering functions, if it

 * has not already been called. So there's no need to call this function

 * explicitly.

 */

BGD_DECLARE(int) gdFontCacheSetup (void)

{

	if (fontCache) {

		/* Already set up */

		return 0;

	}

	gdMutexSetup (gdFontCacheMutex);

	if (FT_Init_FreeType (&library)) {

		gdMutexShutdown (gdFontCacheMutex);

		return -1;

	}

	fontCache = gdCacheCreate (FONTCACHESIZE, fontTest, fontFetch, fontRelease);

	if (!fontCache) {

		return -2;

	}

	return 0;

}

/*

  Function: gdImageStringFTEx

  gdImageStringFTEx extends the capabilities of gdImageStringFT by

  providing a way to pass additional parameters.

  If the strex parameter is not null, it must point to a

  gdFTStringExtra structure. As of gd 2.0.5, this structure is defined

  as follows:

  (start code)

  typedef struct {

      // logical OR of gdFTEX_ values

      int flags;

      // fine tune line spacing for '\n'

      double linespacing;

      // Preferred character mapping

      int charmap;