X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fttf.cpp;h=799f0321ffc288aad01c42836e19b991d961d0c7;hb=0c01fa32c7e0629ae61992e0419f03724fc18487;hp=124468728d8efcdf58d8e94c516484faaf95f3bd;hpb=6d13a5166688e470590692eb91c3915ab332fe36;p=ttedit

diff --git a/src/ttf.cpp b/src/ttf.cpp
index 1244687..799f032 100755
--- a/src/ttf.cpp
+++ b/src/ttf.cpp
@@ -1,1212 +1,1212 @@
-//
-// TTF.CPP - The TrueType class
-// by James L. Hammons
-// (C) 2005 Underground Software
-//
-// This class encapsulates all the complexity of a TrueType Font File
-// database.  Included are functions to load, save, & initialize the
-// TTF database, move, add, & delete points & glyphs, i.e. manipulate
-// a TTF file in just about any way imaginable!
-//
-// JLH = James L. Hammons <jlhamm@acm.org>
-//
-// Who  When        What
-// ---  ----------  -------------------------------------------------------------
-// JLH  ??/??/199?  Created this file
-//
-//
-// STILL TO BE DONE:
-//
-// - Eliminate ALL references to BYTE, WORD, SBYTE, SWORD, etc.
-//
-
-#include <stdio.h>								// For file handling, etc.												//
-#include <stdlib.h>
-#include <string.h>
-#include "charnames.h"
-#include "ttf.h"
-
-#define TTFDEBUG
-
-#ifdef TTFDEBUG
-#include "debug.h"
-#endif
-
-#define NUMTABS  24                   // Number of distinct tables
-
-
-/*void fskip(HANDLE file, uint32 bytesToSkip)
-{
-	SetFilePointer(file, (LONG)bytesToSkip, NULL, FILE_CURRENT);
-}*/
-
-//
-// Get a BYTE from the current file...
-//
-uint8 ReadByte(FILE * file)
-{
-	return (uint8)fgetc(file);
-}
-
-// The following routines get and put WORDs and DWORDs in little endian
-// format, so they should work no matter what endianess the platform that
-// holds the TTF object.
-
-//
-// Get a WORD from the current file...
-//
-uint16 ReadWord(FILE * file)
-{
-	uint16 word = (uint16)fgetc(file) << 8;
-	word |= (uint16)fgetc(file);
-
-	return word;
-}
-
-//
-// Get a double WORD from the current file...
-//
-uint32 ReadDWord(FILE * file)
-{
-	uint32 dword = 0;
-
-	for(int i=0; i<4; i++)
-	{
-		dword <<= 8;
-		dword |= (uint8)fgetc(file);
-	}
-
-	return dword;
-}
-
-//
-// Write a WORD to the current file...
-//
-void WriteWord(FILE * file, uint16 word)
-{
-	fputc(word >> 8, file);						// Hi byte
-	fputc(word & 0xFF, file);					// Lo byte
-}
-
-//
-// Write a double WORD to the current file...
-//
-void WriteDWord(FILE * file, uint32 dword)
-{
-	for(int i=0; i<4; i++)
-	{
-		fputc((char)(dword >> 24), file);
-		dword <<= 8;
-	}
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Table extraction helper routines (inline 'em?)
-////////////////////////////////////////////////////////////////////////////
-
-//
-// Return a BYTE from a BYTE based table
-//
-uint8 GetByte(uint8 * table, uint32 &ptr)
-{
-	return table[ptr++];
-}
-
-//
-// Return a WORD from a BYTE based table
-//
-uint16 GetWord(uint8 * table, uint32 &ptr)
-{
-	uint16 hi = table[ptr++];
-	uint16 lo = table[ptr++];
-
-	return (uint16)((hi<<8) | lo);
-}
-
-//
-// Return a double WORD from a BYTE based table
-//
-uint32 GetDWord(uint8 * table, uint32 &ptr)
-{
-	uint32 hi1 = table[ptr++];
-	uint32 lo1 = table[ptr++];
-	uint32 hi2 = table[ptr++];
-	uint32 lo2 = table[ptr++];
-
-	return (uint32)((hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Table storage helper routines (inline 'em?)
-////////////////////////////////////////////////////////////////////////////
-
-//
-// Store a BYTE in a BYTE based table
-//
-void SetByte(uint8 * table, uint32 &ptr, uint8 data)
-{
-	table[ptr++] = data;
-}
-
-//
-// Store a WORD in a BYTE based table
-//
-void SetWord(uint8 * table, uint32 &ptr, uint16 data)
-{
-	table[ptr++] = data>>8;  table[ptr++] = data&0xFF;
-}
-
-//
-// Store a DWORD in a BYTE based table
-//
-void SetDWord(uint8 * table, uint32 &ptr, uint32 data)
-{
-	table[ptr++] = (uint8)(data >> 24); table[ptr++] = (uint8)(data >> 16);
-	table[ptr++] = (uint8)(data >> 8);  table[ptr++] = (uint8)(data & 0xFF);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Fixed point to float (& vice versa) conversions
-/////////////////////////////////////////////////////////////////////////////
-float FixedToFloat(int16 fixed)
-{
-	return (float)fixed / 16384.0f;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// TTF Constructor
-/////////////////////////////////////////////////////////////////////////////
-TTF::TTF(void)
-{
-	loaded = false;								// Set font initializer
-	isDirty = false;							// Glyphs are clean
-	numberOfPolys = 0;							// Set reasonable values
-	isCompositeGlyph = false;					// No composite glyph (yet)
-
-	parray[0] = &EBDT;  parray[1] = &EBLC;  parray[2] = &EBSC; // Init pointer
-	parray[3] = &LTSH;  parray[4] = &OS_2;  parray[5] = &PCLT; // array...
-	parray[6] = &VDMX;  parray[7] = &cmap;  parray[8] = &cvt; 
-	parray[9] = &fpgm;  parray[10] = &gasp; parray[11] = &glyf;
-	parray[12] = &hdmx; parray[13] = &head; parray[14] = &hhea;
-	parray[15] = &hmtx; parray[16] = &kern; parray[17] = &loca;
-	parray[18] = &maxp; parray[19] = &name; parray[20] = &post;
-	parray[21] = &prep; parray[22] = &vhea; parray[23] = &vmtx;
-
-	larray[0] = &EBDT_len;  larray[1] = &EBLC_len;  larray[2] = &EBSC_len;
-	larray[3] = &LTSH_len;  larray[4] = &OS_2_len;  larray[5] = &PCLT_len;
-	larray[6] = &VDMX_len;  larray[7] = &cmap_len;  larray[8] = &cvt_len;
-	larray[9] = &fpgm_len;  larray[10] = &gasp_len; larray[11] = &glyf_len;
-	larray[12] = &hdmx_len; larray[13] = &head_len; larray[14] = &hhea_len;
-	larray[15] = &hmtx_len; larray[16] = &kern_len; larray[17] = &loca_len;
-	larray[18] = &maxp_len; larray[19] = &name_len; larray[20] = &post_len;
-	larray[21] = &prep_len; larray[22] = &vhea_len; larray[23] = &vmtx_len;
-
-	for(uint32 i=0; i<NUMTABS; i++)
-		*parray[i] = NULL;						// Init pointers...
-
-	for(uint32 i=0; i<MAXGLYPHS; i++)
-		glyph[i] = NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// TTF Destructor
-/////////////////////////////////////////////////////////////////////////////
-TTF::~TTF()
-{
-	ClearTables();								// This should handle deallocation correctly...
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: void Init(void)
-//
-// This function initializes the TTF object, setting reasonable values for
-// the various internal variables used by the object.
-// [distinct from New?]
-/////////////////////////////////////////////////////////////////////////////
-void TTF::Init(void)
-{
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Clear the tables so that file can be reloaded
-/////////////////////////////////////////////////////////////////////////////
-void TTF::ClearTables(void)
-{
-	for(uint32 i=0; i<NUMTABS; i++)
-	{
-		if ((*parray[i]) != NULL)
-		{
-			free(*parray[i]);
-			*parray[i] = NULL;
-			*larray[i] = 0;
-		}
-	}  
-
-	for(uint32 i=0; i<MAXGLYPHS; i++)
-	{
-		if (glyph[i] != NULL)
-		{
-			free(glyph[i]);
-			glyph[i] = NULL;
-		}
-	}
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL Load(const char * filename)
-//
-// This loads the TTF database from an external file.  Returns 'true' if
-// successful.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::Load(const char * filename)
-{
-//	unsigned char ch;							// Temp variable
-//	UINT num_tabs;								// Number of tables
-	uint32 offset[NUMTABS], length[NUMTABS];	// Temporary storage...
-	char names[NUMTABS][5];
-	char narray[NUMTABS][5] = { "EBDT", "EBLC", "EBSC", "LTSH", "OS/2", "PCLT",
-		"VDMX", "cmap", "cvt ", "fpgm", "gasp", "glyf", "hdmx", "head", "hhea",
-		"hmtx", "kern", "loca", "maxp", "name", "post", "prep", "vhea", "vmtx" };
-
-	//loaded = false;
-//	file.open(filename, ios::binary|ios::in);	// Open the file
-	FILE * file = fopen(filename, "rb");
-
-	if (file == NULL)
-#ifdef TTFDEBUG
-{
-WriteLogMsg("Failed to open file!\n");
-#endif
-		return false;
-#ifdef TTFDEBUG
-}
-#endif
-
-	if (ReadDWord(file) != 0x00010000)
-#ifdef TTFDEBUG
-{
-WriteLogMsg("File was NOT a TTF file!\n");
-#endif
-		return false;							// Not a TTF file...
-#ifdef TTFDEBUG
-}
-#endif
-
-	uint32 num_tabs = ReadWord(file);			// Get # of tables
-#ifdef TTFDEBUG
-WriteLogMsg("Number of tables is %u...\n", num_tabs);
-#endif
-//	fskip(file, 6);								// Skip this shiat...
-	fseek(file, 6, SEEK_CUR);
-
-#ifdef TTFDEBUG
-WriteLogMsg("Reading names of tables...\n");
-#endif
-	for(uint32 i=0; i<num_tabs; i++)
-	{
-//		ReadFile(file, names[i], 4, &bytesRead, NULL);
-		fread(names[i], 1, 4, file);
-		names[i][4] = 0;
-//		fskip(file, 4);							// Checksum
-		fseek(file, 4, SEEK_CUR);				// Checksum
-		offset[i] = ReadDWord(file);			// Offset from start of file
-		length[i] = ReadDWord(file);			// Length of table
-	}
-
-#ifdef TTFDEBUG
-WriteLogMsg("Reading tables...\n");
-#endif
-	for(uint32 i=0; i<num_tabs; i++)
-	{
-		for(uint32 j=0; j<NUMTABS; j++)
-		{
-			if ((strcmp(names[i], narray[j])) == 0)	// Found a match...
-			{
-//				*parray[j] = (uint8 *)GlobalAlloc(GMEM_FIXED, length[i]);	// Allocate space
-				*parray[j] = (uint8 *)malloc(length[i]); // Alloc space
-
-				if (*parray[j] == NULL)
-					return false;				// Bail out if nothing allocated
-
-				*larray[j] = length[i];			// Set its length...
-//				SetFilePointer(file, (LONG)offset[i], NULL, FILE_BEGIN);
-//				ReadFile(file, *parray[j], length[i], &bytesRead, NULL);
-				fseek(file, offset[i], SEEK_SET);
-				fread(*parray[j], 1, length[i], file);
-				break;
-			}
-		}
-	}
-
-	fclose(file);
-
-// This shouldn't be necessary, since it's irrelevant (loaded flag)
-//    loaded = true;                       // Set 'loaded' flag...
-    isDirty = false;                     // Glyphs are clean
-    ExtractTables();                     // Move table data to my structs
-                                         // & ignore return val
-                                         // (should handle errors here)
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL Save(const char * filename)
-//
-// Save the TT font currently in the object
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::Save(const char * filename)
-{
-//  fstream file;
-//	ULONG offset = 12;
-	uint32 numtabs = 0;
-	char padding[3] = { 0, 0, 0 };
-	// Convert this to a table of ULONGs to decrease complexity...
-//wouldn't be endian safe then...
-	char narray[NUMTABS][5] = { "EBDT", "EBLC", "EBSC", "LTSH", "OS/2", "PCLT",
-		"VDMX", "cmap", "cvt ", "fpgm", "gasp", "glyf", "hdmx", "head", "hhea",
-		"hmtx", "kern", "loca", "maxp", "name", "post", "prep", "vhea", "vmtx" };
-
-	if (isDirty)
-		EncodeGlyph(currentGlyph);
-
-	BuildTables();								// Ignore return value...  
-
-	for(uint32 i=0; i<NUMTABS; i++)				// Figure out how many tables there are
-		if ((*parray[i]) != NULL)
-			numtabs++;
-
-	uint32 offset = 12 + (numtabs * 16);		// Calc correct offset to start of data
-
-//	HANDLE file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
-//		NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-	FILE * file = fopen(filename, "wb");
-
-	WriteDWord(file, 0x00010000);				// Write header...
-	WriteWord(file, numtabs);
-	WriteWord(file, 0);							// SearchRange (Max power of 2 <= numTables) x 16.
-	WriteWord(file, 0);							// entrySelector Log2(max power of 2 <= numTables).
-	WriteWord(file, 0);							// NumTables x 16 - searchRange.
-
-	for(uint32 i=0; i<NUMTABS; i++)					// Write out table directory...
-	{
-		if ((*parray[i]) != NULL)
-		{
-//			for(int j=0; j<4; j++)
-//				file.put(narray[i][j]);			// Name
-//			WriteFile(file, narray[i], 4, &bytesWritten, NULL);
-			fwrite(narray[i], 1, 4, file);		// Name
-
-			WriteDWord(file, 0);				// Checksum
-			WriteDWord(file, offset);			// Offset
-			WriteDWord(file, (*larray[i]));		// Length
-
-			offset += (((*larray[i]) + 3) & ~3);	// Pad out to 4-uint8 boundary...
-		}
-	}
-
-	for(uint32 i=0; i<NUMTABS; i++)					// Write out the tables...
-	{
-		if ((*parray[i]) != NULL)
-		{
-//			for(uint32 j=0; j<(*larray[i]); j++)
-//				file.put((*parray[i])[j]);
-//			WriteFile(file, *parray[i], *larray[i], &bytesWritten, NULL);
-			fwrite(*parray[i], 1, *larray[i], file);
-
-			uint32 remainder = ((*larray[i]) & 0x3);
-			if (remainder)               // i.e., it's not evenly div by 4
-//				for(j=remainder; j<4; j++)
-//					file.put((char)0);       // pad it!
-//				WriteFile(file, padding, 4 - remainder, &bytesWritten, NULL);
-				fwrite(padding, 1, 4 - remainder, file);
-		}
-	}
-
-	fclose(file);
-
-	return true;								// Whether or not it was successful...
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL EncodeGlyph(int glyphnum)
-//
-// This function encodes the glyph data and stores it to the 'glyf' table.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::EncodeGlyph(uint16 glyphnum)
-{
-	bool retval = false;						// Assume failure
-	uint8 flag, xbuf[4000], ybuf[4000], fbuf[2000];
-	uint32 xp = 0, yp = 0, fp = 0;				// Table pointers
-
-	if (glyphnum < myMaxp.numGlyphs)  // numofgls is 1 based ind, glyph# 0 based
-	{
-		// need to add composite encoding...
-		int lastx = 0, lasty = 0;
-
-		for(uint32 i=0; i<numberOfPoints; i++)
-		{
-			flag = 0;
-			int curx = gx[i] - lastx, cury = gy[i] - lasty;
-
-			if (onCurve[i])
-				flag |= 0x01;					// Set on curve info
-
-			if (curx)
-			{
-				if ((curx > 255) || (curx < -255)) // I.e., it's 2 uint8 value
-					SetWord(xbuf, xp, curx);
-				else
-				{
-					if (curx & 0x100)
-					{
-						flag |= 0x02; // I.e., it's negative
-						curx *= -1;   // Flip it so correct value is stored
-					}
-					else
-						flag |= 0x12;
-
-					SetByte(xbuf, xp, curx);	// Automagically strips neg bit
-				}
-			}
-			else
-				flag |= 0x10;					// X-coord is same...
-  
-			if (cury)
-			{
-				if ((cury > 255) || (cury < -255)) // I.e., it's 2 uint8 value
-					SetWord(ybuf, yp, cury);
-				else
-				{
-					if (cury & 0x100)
-					{
-						flag |= 0x04; // I.e., it's negative
-						cury *= -1;
-					}
-					else
-						flag |= 0x24;
-            
-					SetByte(ybuf, yp, cury);
-				}
-			}
-			else
-				flag |= 0x20;                 // Y-coord is same...
-  
-			fbuf[i] = flag;
-			lastx = gx[i];  lasty = gy[i];
-		}
-
-		// Now crunch flags...  ugly, ugly, ugly.
-/*
-    fbuf[numberOfPoints] = 0;  // Set sentinel value (ugly way to do this)
-    for(i=0; i<numberOfPoints; i++);
-    {
-      if (fbuf[i] == fbuf[i+1])  // 
-      {
-        uint8 count = 0;  // Sentinel takes care of check for end of flags...
-        while (fbuf[i] == fbuf[++i])  count++; // Count number of repeats
-        i--;
-        fbuf[fp++] = fbuf[i] | 0x08; // Set repeat flag
-        fbuf[fp++] = count;          // & number of repeats
-      }
-      else  fbuf[fp++] = fbuf[i];    // Otherwise, just copy...
-    }
-*/
-		fp = numberOfPoints;
-		// Find length of glyph and reallocate space if necessary
-
-		uint32 newLength = 12 + numberOfPolys*2 + numberOfHints + fp + xp + yp;
-
-		if (newLength & 0x03)
-			newLength += (4 - newLength & 0x03);
-
-		if (glyphLen[glyphnum] != newLength)
-		{
-			glyph[glyphnum] = (uint8 *)realloc(glyph[glyphnum], newLength);
-			glyphLen[glyphnum] = newLength;
-		}
-
-		// And finally, store it!
-
-		uint32 gp = 0;							// Glyph pointer...
-		SetWord(glyph[glyphnum], gp, numberOfPolys);
-		SetWord(glyph[glyphnum], gp, llx);
-		SetWord(glyph[glyphnum], gp, lly);
-		SetWord(glyph[glyphnum], gp, urx);
-		SetWord(glyph[glyphnum], gp, ury);
-		for(uint32 i=0; i<numberOfPolys; i++)
-			SetWord(glyph[glyphnum], gp, poly[i]);
-		SetWord(glyph[glyphnum], gp, numberOfHints);
-		for(uint32 i=0; i<numberOfHints; i++)
-			SetByte(glyph[glyphnum], gp, hint[i]);
-		for(uint32 i=0; i<fp; i++)
-			SetByte(glyph[glyphnum], gp, fbuf[i]);
-		for(uint32 i=0; i<xp; i++)
-			SetByte(glyph[glyphnum], gp, xbuf[i]);
-		for(uint32 i=0; i<yp; i++)
-			SetByte(glyph[glyphnum], gp, ybuf[i]);
-
-		retval = true;							// Successfully encoded!
-	}
-
-	return retval;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL DecodeGlyph(int glyphnum)
-//
-// This function decodes the glyph data and stores it to the object's
-// internal array.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::DecodeGlyph(uint16 glyphnum)
-{
-	bool retval = false;
-	uint32 i, dp;
-
-	// glyphnum is 0 based index, while numGlyphs is 1 based
-	if (glyphnum >= myMaxp.numGlyphs)
-		return false;  // Invalid char #
-
-	if (!glyphLen[glyphnum])
-	{
-		numberOfPoints = numberOfPolys = 0;
-		return true;							// Zero length IS valid...
-	}
-//	else										// Get character data...
-//	{
-    // Now get the character data...
-	dp = 0;                     // Reset data pointer
-	isCompositeGlyph = false;   // Default is no
-	numberOfPolys = GetWord(glyph[glyphnum], dp);  // # of polygons
-
-	llx = (int16)GetWord(glyph[glyphnum], dp);           // Lower left X
-	lly = (int16)GetWord(glyph[glyphnum], dp);           // Lower left Y
-	urx = (int16)GetWord(glyph[glyphnum], dp);           // Upper right X
-	ury = (int16)GetWord(glyph[glyphnum], dp);           // Upper right Y
-
-	// Need to handle composite glyphs better here.  The ways things
-	// are set now is a recipe for disaster...
-
-	if (numberOfPolys == 0xFFFF)
-	{
-		isCompositeGlyph = true;
-		numberOfPolys = 0;						// Set for no points
-
-		Composite cmpst;
-
-		while (!compositeList.IsEmpty())		// Empty composite list...
-			compositeList.GetFront();
-
-		do
-		{
-			cmpst.flags = GetWord(glyph[glyphnum], dp);
-			cmpst.glyphIndex = GetWord(glyph[glyphnum], dp);
-			cmpst.arg1 = (cmpst.flags & 0x01 ? (int16)GetWord(glyph[glyphnum], dp) : (int8)GetByte(glyph[glyphnum], dp));
-			cmpst.arg2 = (cmpst.flags & 0x01 ? (int16)GetWord(glyph[glyphnum], dp) : (int8)GetByte(glyph[glyphnum], dp));
-
-			if (cmpst.flags & 0x08)
-				cmpst.xScale = cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
-			else if (cmpst.flags & 0x40)
-				cmpst.xScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
-			else if (cmpst.flags & 0x80)
-				cmpst.xScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.scale01 = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.scale10 = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
-
-			compositeList.AddAtRear(cmpst);
-		}
-		while (cmpst.flags & 0x20); //*/
-
-		return true;
-	}
-
-//do {
-//	USHORT flags;
-//	USHORT glyphIndex;
-//	if ( flags & ARG_1_AND_2_ARE_uint16S) {
-//	(SHORT or Fuint16) argument1;
-//	(SHORT or Fuint16) argument2;
-//	} else {
-//		USHORT arg1and2; /* (arg1 << 8) | arg2 */
-//	}
-//	if ( flags & WE_HAVE_A_SCALE ) {
-//		F2Dot14  scale;    /* Format 2.14 */
-//	} else if ( flags & WE_HAVE_AN_X_AND_Y_SCALE ) {
-//		F2Dot14  xscale;    /* Format 2.14 */
-//		F2Dot14  yscale;    /* Format 2.14 */
-//	} else if ( flags & WE_HAVE_A_TWO_BY_TWO ) {
-//		F2Dot14  xscale;    /* Format 2.14 */
-//		F2Dot14  scale01;   /* Format 2.14 */
-//		F2Dot14  scale10;   /* Format 2.14 */
-//		F2Dot14  yscale;    /* Format 2.14 */
-//	}
-//} while ( flags & MORE_COMPONENTS ) 
-//if (flags & WE_HAVE_INSTR){
-//	USHORT numInstr
-//	uint8 instr[numInstr]
-//
-//Flags                    Bit     Description 
-//ARG_1_AND_2_ARE_uint16S    0       If this is set, the arguments are uint16s;
-//                                 otherwise, they are uint8s.
-//ARGS_ARE_XY_VALUES       1       If this is set, the arguments are xy values;
-//                                 otherwise, they are points.
-//ROUND_XY_TO_GRID         2       For the xy values if the preceding is true.
-//WE_HAVE_A_SCALE          3       This indicates that there is a simple scale
-//                                 for the component. Otherwise, scale = 1.0.
-//RESERVED                 4       This bit is reserved.  Set it to 0. 
-//MORE_COMPONENTS          5       Indicates at least one more glyph after this
-//                                 one.
-//WE_HAVE_AN_X_AND_Y_SCALE 6       The x direction will use a different scale
-//                                 from the y direction.
-//WE_HAVE_A_TWO_BY_TWO     7       There is a 2 by 2 transformation that will
-//                                 be used to scale the component.
-//WE_HAVE_INSTRUCTIONS     8       Following the last component are
-//                                 instructions for the composite character.
-//USE_MY_METRICS           9       If set, this forces the aw and lsb (and rsb)
-//                                 for the composite to be equal to those from
-//                                 this original glyph. This works for hinted
-//                                 and unhinted characters.
-
-	for(i=0; i<numberOfPolys; i++)
-		poly[i] = GetWord(glyph[glyphnum], dp);
-
-	numberOfHints = GetWord(glyph[glyphnum], dp);
-
-	for(i=0; i<numberOfHints; i++)
-		hint[i] = GetByte(glyph[glyphnum], dp);
-
-	// Decode the dots...
-
-	uint32 num_pts = poly[numberOfPolys-1] + 1;
-	numberOfPoints = num_pts; // necessary??
-	uint32 xptr, yptr;        // pointers to beginning of coord data
-	uint32 numXs = 0;
-	int xx = 0, yy = 0, repeat;
-	uint32 numTokens = num_pts, k, numRep;
-
-	// We make an educated guess that num_pts = num_tokens; but if there
-	// is repeated data in the tokens, then we need to adjust the # of
-	// tokens down appropriately.
-
-	for(uint32 i=0; i<numTokens; i++)
-	{
-		uint8 token = glyph[glyphnum][dp+i];  uint32 rpts = 1;
-
-		if (token & 0x08)      // Repeated token?
-		{
-			i++;                 // Yes, bump pointer to # of times to repeat
-			numRep = glyph[glyphnum][dp+i];
-			rpts += numRep;
-
-			if (numRep > 1)      // Do we need to adjust numTokens?
-   // this is bad, modifying numTokens while it's used as a compare value
-   // in the above loop...
-   // Is it necessary to do so in order to keep from going too far?
-			numTokens -= (numRep - 1); // Yes, adjust.
-		}
-
-		// 10 = same x(0uint8s), 00 = 2uint8s, 02&12 = 1uint8
-		if ((token & 0x02) == 0x02)
-			numXs += rpts;
-
-		if ((token & 0x12) == 0x00)
-			numXs += (rpts*2);
-	}
-
-	xptr = dp + numTokens;
-	yptr = dp + numTokens + numXs;
-
-	// & continue decoding X/Y-coords...
-
-	k = 0;                               // Index to the point array
-
-	for(uint32 i=0; i<numTokens; i++)
-	{
-		uint8 token = glyph[glyphnum][dp+i];
-		repeat = 1;
-
-		if (token & 0x08)
-		{
-			i++;
-			repeat += glyph[glyphnum][dp+i]; // Set repeat data...
-		}
-
-		while (repeat--)
-		{
-			if ((token & 0x12) == 0x12)
-				xx += GetByte(glyph[glyphnum], xptr);
-
-			if ((token & 0x12) == 0x02)
-				xx -= GetByte(glyph[glyphnum], xptr);
-
-			if ((token & 0x12) == 0x00)
-				xx += (int16)GetWord(glyph[glyphnum], xptr);
-
-			gx[k] = xx;                      // Store x-coordinate
-
-			if ((token & 0x24) == 0x24)
-				yy += GetByte(glyph[glyphnum], yptr);
-
-			if ((token & 0x24) == 0x04)
-				yy -= GetByte(glyph[glyphnum], yptr);
-
-			if ((token & 0x24) == 0x00)
-				yy += (int16)GetWord(glyph[glyphnum], yptr);
-
-			gy[k] = yy;                      // Store y-coordinate
-
-			onCurve[k++] = (token & 0x01 ? true : false);  // If bit 0 set, then it's on curve
-		}
-	}
-
-	retval = true;							// Hmm. Successfully decoded a glyph...
-//	}
-
-	isDirty = false;  // do it here?
-
-	return retval;
-}
-
-/*****************************************************************************
- Member function:
-
- This function decodes the 'glyf' data for a non-composite (atomic) glyph and
- returns it as a GlyphPoints object. Helper function.
- *****************************************************************************/
-GlyphPoints TTF::GetGlyphPoints(uint16 glyphNum)
-{
-	if (DecodeGlyph(glyphNum))
-		return GlyphPoints(numberOfPoints, numberOfPolys, gx, gy, onCurve, poly);
-
-	return GlyphPoints();
-}
-
-/*****************************************************************************
- Member function:
-
- This function decodes the 'glyf' data for a composite glyph and returns
- it as a GlyphPoints object.
- *****************************************************************************/
-GlyphPoints TTF::GetAllCompositePoints(uint16 glyphNum)
-{
-//  int tmpGlyph = currentGlyph;
-  
-	DecodeGlyph(glyphNum);         // Check for composite-ness
-
-	if (!isCompositeGlyph)
-		return GlyphPoints();
-
-/*
-  for(int i=1; i<=pDoc->m_myFont.compositeList.Length(); i++)
-  {
-    TComposite cmpst = fnt->compositeList.PeekPosition(i);
-    fnt->SetGlyph(cmpst.glyphIndex);
-    if (cmpst.flags & 0x0002)
-      m_nXOffset = cmpst.arg1, m_nYOffset = cmpst.arg2;
-    ScanConvertSingleGlyph(pDC, nScanlines, nHorzLines, nXOffset, nYOffset);
-  }
-  fnt->SetGlyph(pDoc->character_num);
-*/
-
-	GlyphPoints retVal;
-
-	for(int i=1; i<=compositeList.Length(); i++)
-	{
-		Composite cmpst = compositeList.PeekPosition(i);
-    
-//    SetGlyph(cmpst.glyphIndex);
-//    if (cmpst.flags & 0x0002)
-//      m_nXOffset = cmpst.arg1, m_nYOffset = cmpst.arg2;
-//    ScanConvertSingleGlyph(pDC, nScanlines, nHorzLines, nXOffset, nYOffset);
-		GlyphPoints gp = GetGlyphPoints(cmpst.glyphIndex);
-
-		if (cmpst.flags & 0x0002)
-			gp.OffsetPoints(cmpst.arg1, cmpst.arg2);
-
-		retVal = retVal + gp;
-		// NOTE: May have to adjust scanlines as per 0x0002 above...
-	}
-
-//  SetGlyph(tmpGlyph);
-	DecodeGlyph(currentGlyph);     // Reset needed here...
-
-	return retVal;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: void GetCharName(int cNum, uint8 * buf)
-//
-// This function returns the character name of the glyph number passed in.
-/////////////////////////////////////////////////////////////////////////////
-void TTF::GetCharName(int cNum, uint8 * buf)
-{
-	buf[0] = 0;									// Set failure as default condition
-  
-	if (!post)									// PS names are here...
-		return;
-
-	if (post[1] != 0x02 || post[2] != 0x00)		// i.e., it's NOT a V2.0 table
-		return;
-
-	uint8 * pTab = NULL;
-	uint32 tabOff = 34, numGlyphs = (uint32)((post[32] << 8) | post[33]);
-	uint32 index = (uint32)((post[tabOff + cNum * 2] << 8) | post[tabOff + cNum * 2 + 1]);
-	uint32 nInd2;
-
-	if (index > 257)
-	{
-		index -= 258;
-		nInd2 = tabOff + (2 * numGlyphs);
-		pTab = post;
-	}
-	else
-	{
-		nInd2 = 0;
-		pTab = macStdNames;
-	}
-
-	for(uint32 i=0; i<index; i++)
-		nInd2 = nInd2 + pTab[nInd2] + 1; // 1st uint8 is length of string + that uint8
-
-	uint8 len = pTab[nInd2];
-	nInd2++;
-
-	for(uint8 i=0; i<len; i++)
-		buf[i] = pTab[nInd2 + i];
-
-	buf[len] = 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL ExtractTables(void)
-//
-// This function extracts the data from the various tables and puts them in
-// various structs for easier handling of the font data.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::ExtractTables(void)
-{
-	if (head_len != 54)
-	{
-#ifdef TTFDEBUG
-WriteLogMsg("Bad HEAD header: Expected 54, found %u...\n", head_len);
-#endif
-		return false;							// Corrupt data?
-	}
-
-	uint32 tp = 0;
-	myHead.version            = GetDWord(head, tp);
-	myHead.fontRevision       = GetDWord(head, tp);
-	myHead.checkSumAdjustment = GetDWord(head, tp);
-	myHead.magicNumber        = GetDWord(head, tp);
-	myHead.flags              = GetWord(head, tp);
-	myHead.unitsPerEm         = GetWord(head, tp);
-	myHead.createdh           = GetDWord(head, tp);
-	myHead.createdl           = GetDWord(head, tp);
-	myHead.modifiedh          = GetDWord(head, tp);
-	myHead.modifiedl          = GetDWord(head, tp);
-	myHead.xMin               = GetWord(head, tp);
-	myHead.yMin               = GetWord(head, tp);
-	myHead.xMax               = GetWord(head, tp);
-	myHead.yMax               = GetWord(head, tp);
-	myHead.macStyle           = GetWord(head, tp);
-	myHead.lowestRecPPEM      = GetWord(head, tp);
-	myHead.fontDirectionHint  = (int16)GetWord(head, tp);
-	myHead.indexToLocFormat   = (int16)GetWord(head, tp);
-	myHead.glyphDataFormat    = (int16)GetWord(head, tp);
-
-	if (maxp_len != 32)
-	{
-#ifdef TDEBUG
-WriteLogMsg("Bad MAXP header: Expected 32, found %u...\n", maxp_len);
-#endif
-		return false;							// Corrupt data?
-	}
-
-	tp = 0;										// Reset table pointer
-	myMaxp.version               = GetDWord(maxp, tp);
-	myMaxp.numGlyphs             = GetWord(maxp, tp);
-	myMaxp.maxPoints             = GetWord(maxp, tp);
-	myMaxp.maxContours           = GetWord(maxp, tp);
-	myMaxp.maxCompositePoints    = GetWord(maxp, tp);
-	myMaxp.maxCompositeContours  = GetWord(maxp, tp);
-	myMaxp.maxZones              = GetWord(maxp, tp);
-	myMaxp.maxTwilightPoints     = GetWord(maxp, tp);
-	myMaxp.maxStorage            = GetWord(maxp, tp);
-	myMaxp.maxFunctionDefs       = GetWord(maxp, tp);
-	myMaxp.maxInstructionDefs    = GetWord(maxp, tp);
-	myMaxp.maxStackElements      = GetWord(maxp, tp);
-	myMaxp.maxSizeOfInstructions = GetWord(maxp, tp);
-	myMaxp.maxComponentElements  = GetWord(maxp, tp);
-	myMaxp.maxComponentDepth     = GetWord(maxp, tp);
-
-	tp = 0;										// Reset table pointer
-	uint32 start = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
-
-	for(uint32 i=0; i<myMaxp.numGlyphs; i++)
-	{
-		uint32 end = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
-		uint32 length = end - start;
-		glyphLen[i] = length;					// Lengths are saved 'cause malloc is sloppy
-
-		if (length)     // loca+start? pointer arithmetic?
-		{
-			glyph[i] = (uint8 *)malloc(length);	// Allocate space,
-			memcpy(glyph[i], glyf+start, length);	// and move it!
-		}
-		else
-			glyph[i] = NULL;
-
-		start = end;							// Reset start value
-	}
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL BuildTables(void)
-//
-// This function builds the various TTF tables using info in the various
-// structs so that a TTF file can be written out to disk.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::BuildTables(void)
-{
-	uint32 i, tp, start;
-
-	myHead.indexToLocFormat = 1;				// We don't bother with [uint16s*2] format...
-
-	// Build HEAD table
-
-	tp = 0;										// Reset table pointer
-	SetDWord(head, tp, myHead.version);//            = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.fontRevision);//       = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.checkSumAdjustment);// = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.magicNumber);//        = GetDWord(head, tp);
-	SetWord(head, tp, myHead.flags);//              = GetWord(head, tp);
-	SetWord(head, tp, myHead.unitsPerEm);//         = GetWord(head, tp);
-	SetDWord(head, tp, myHead.createdh);//           = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.createdl);//           = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.modifiedh);//          = GetDWord(head, tp);
-	SetDWord(head, tp, myHead.modifiedl);//          = GetDWord(head, tp);
-	SetWord(head, tp, myHead.xMin);//               = GetWord(head, tp);
-	SetWord(head, tp, myHead.yMin);//               = GetWord(head, tp);
-	SetWord(head, tp, myHead.xMax);//               = GetWord(head, tp);
-	SetWord(head, tp, myHead.yMax);//               = GetWord(head, tp);
-	SetWord(head, tp, myHead.macStyle);//           = GetWord(head, tp);
-	SetWord(head, tp, myHead.lowestRecPPEM);//      = GetWord(head, tp);
-	SetWord(head, tp, myHead.fontDirectionHint);//  = (int16)GetWord(head, tp);
-	SetWord(head, tp, myHead.indexToLocFormat);//   = (int16)GetWord(head, tp);
-	SetWord(head, tp, myHead.glyphDataFormat);//    = (int16)GetWord(head, tp);
-
-	// Build MAXP table
-
-	tp = 0;										// Reset table pointer
-	SetDWord(maxp, tp, myMaxp.version);//               = GetDWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.numGlyphs);//             = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxPoints);//             = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxContours);//           = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxCompositePoints);//    = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxCompositeContours);//  = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxZones);//              = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxTwilightPoints);//     = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxStorage);//            = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxFunctionDefs);//       = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxInstructionDefs);//    = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxStackElements);//      = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxSizeOfInstructions);// = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxComponentElements);//  = GetWord(maxp, tp);
-	SetWord(maxp, tp, myMaxp.maxComponentDepth);//     = GetWord(maxp, tp);
-
-	// Build LOCA & GLYF tables
-
-	loca_len = (myMaxp.numGlyphs+1) * 4;		// Set size of table
-
-	if (loca)
-		free(loca);								// And create/reallocate it...
-
-	loca = (uint8 *) malloc(loca_len);
-
-	glyf_len = 0;								// Refigure glyf table length
-
-	for(i=0; i<myMaxp.numGlyphs; i++)
-		glyf_len += glyphLen[i];
-
-	if (glyf)
-		free(glyf);
-
-	glyf = (uint8 *) malloc(glyf_len);
-
-	start = tp = 0;								// Reset table pointer
-
-	for(i=0; i<myMaxp.numGlyphs; i++)
-	{
-		SetDWord(loca, tp, start);				// Store glyph start address
-
-		if (glyphLen[i])
-			memcpy(glyf+start, glyph[i], glyphLen[i]);
-
-		start += glyphLen[i];
-	}
-
-	SetDWord(loca, tp, start);					// Finally, store end of glyphs+1
-
-	return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL SetGlyph(int glyphnum)
-//
-// This function decodes the glyph data and stores the points in its own
-// internal array.  If the flag isDirty is set, it also encodes the internal
-// array and stores it to the 'glyf' table.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::SetGlyph(uint16 glyphnum)
-{
-	bool retval = false;						// Set failure as default
-
-	if (isDirty)
-		EncodeGlyph(currentGlyph);
-
-	isDirty = false;
-
-	if (glyphnum < myMaxp.numGlyphs)			// numofgls is 1 based ind, glyph# 0 based
-	{
-		currentGlyph = glyphnum;
-		DecodeGlyph(currentGlyph);
-		retval = true;
-	}
-
-	return retval;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL AddGlyph(int glyphnum)
-//
-// This function adds a glyph of zero size at position glyphnum.  If glyphnum
-// is greater than the number of glyphs, glyph is added at end of list. This
-// glyph then becomes the current glyph.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::AddGlyph(uint16 glyphnum)
-{
-	// incomplete: JLH
-	bool retval = false;
-
-	if (isDirty)
-		EncodeGlyph(currentGlyph);
-
-	isDirty = false;
-
-	return retval;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Member function: BOOL DeleteGlyph(int glyphnum)
-//
-// This function deletes the glyph at position glyphnum.  All glyphs after
-// this glyph are moved down in position.
-/////////////////////////////////////////////////////////////////////////////
-bool TTF::DeleteGlyph(uint16 glyphnum)
-{
-	// incomplete: JLH
-	bool retval = false;
-
-	return retval;
-}
-
-//
-// Various & sundry member functions implementation
-//
-// NOTE: For error handling, should throw exceptions--not return values...! !!! FIX !!!
-//
-
-Box TTF::GetBoundingBox(void)
-{
-	return Box(llx, lly, urx, ury);
-}
-
-GlyphPt TTF::GetPoint(uint16 pointno)
-{
-	GlyphPt p;
-
-	if (pointno >= MAXPOINTS)
-		return p; // Fix to make invalid
-
-	p.x = gx[pointno], p.y = gy[pointno], p.onCurve = onCurve[pointno];
-	return p;
-}
-
-uint16 TTF::GetNumberOfPolys(void)
-{
-	return numberOfPolys;
-}
-
-uint16 TTF::GetPolyEnd(uint16 polynum)
-{
-	if (polynum >= numberOfPolys)
-		return 0;
-
-	return poly[polynum];
-}
-
-int TTF::GetPointX(uint16 pointno)
-{
-	if (pointno >= MAXPOINTS)
-		return 0;
-
-	return gx[pointno];
-}
-
-int TTF::GetPointY(uint16 pointno)
-{
-	if (pointno >= MAXPOINTS)
-		return 0;
-
-	return gy[pointno];
-}
-
-bool TTF::GetOnCurve(uint16 pointno)
-{
-	if (pointno >= MAXPOINTS)
-		return true;
-
-	return onCurve[pointno];
-}
-
-bool TTF::SetOnCurve(uint16 pointno, bool state)
-{
-	if (pointno >= numberOfPoints)
-		return false;
-
-	onCurve[pointno] = state;
-	isDirty = true;
-
-	return true;
-}
-
-bool TTF::MovePoint(uint16 pointno, int x, int y)
-{
-	if (pointno >= numberOfPoints)
-		return false;
-
-	gx[pointno] = x;  gy[pointno] = y;
-	isDirty = true;
-
-	return true;
-}
-
-bool TTF::MovePoint(uint16 pointno, GlyphPt p)
-{
-	if (pointno >= numberOfPoints)
-		return false;
-
-	gx[pointno] = p.x;  gy[pointno] = p.y;  onCurve[pointno] = p.onCurve;
-	isDirty = true;
-
-	return true;
-}
-
-bool TTF::IsCompositeGlyph(void)
-{
-	return isCompositeGlyph;
-}
-
+//
+// TTF.CPP - The TrueType class
+// by James L. Hammons
+// (C) 2005 Underground Software
+//
+// This class encapsulates all the complexity of a TrueType Font File
+// database.  Included are functions to load, save, & initialize the
+// TTF database, move, add, & delete points & glyphs, i.e. manipulate
+// a TTF file in just about any way imaginable!
+//
+// JLH = James L. Hammons <jlhamm@acm.org>
+//
+// Who  When        What
+// ---  ----------  -------------------------------------------------------------
+// JLH  ??/??/199?  Created this file
+//
+//
+// STILL TO BE DONE:
+//
+// - Eliminate ALL references to BYTE, WORD, SBYTE, SWORD, etc.
+//
+
+#include <stdio.h>								// For file handling, etc.
+#include <stdlib.h>
+#include <string.h>
+#include "charnames.h"
+#include "ttf.h"
+
+#define TTFDEBUG
+
+#ifdef TTFDEBUG
+#include "debug.h"
+#endif
+
+#define NUMTABS  24                   // Number of distinct tables
+
+
+/*void fskip(HANDLE file, uint32_t bytesToSkip)
+{
+	SetFilePointer(file, (LONG)bytesToSkip, NULL, FILE_CURRENT);
+}*/
+
+//
+// Get a BYTE from the current file...
+//
+uint8_t ReadByte(FILE * file)
+{
+	return (uint8_t)fgetc(file);
+}
+
+// The following routines get and put WORDs and DWORDs in little endian
+// format, so they should work no matter what endianess the platform that
+// holds the TTF object.
+
+//
+// Get a WORD from the current file...
+//
+uint16_t ReadWord(FILE * file)
+{
+	uint16_t word = (uint16_t)fgetc(file) << 8;
+	word |= (uint16_t)fgetc(file);
+
+	return word;
+}
+
+//
+// Get a double WORD from the current file...
+//
+uint32_t ReadDWord(FILE * file)
+{
+	uint32_t dword = 0;
+
+	for(int i=0; i<4; i++)
+	{
+		dword <<= 8;
+		dword |= (uint8_t)fgetc(file);
+	}
+
+	return dword;
+}
+
+//
+// Write a WORD to the current file...
+//
+void WriteWord(FILE * file, uint16_t word)
+{
+	fputc(word >> 8, file);						// Hi byte
+	fputc(word & 0xFF, file);					// Lo byte
+}
+
+//
+// Write a double WORD to the current file...
+//
+void WriteDWord(FILE * file, uint32_t dword)
+{
+	for(int i=0; i<4; i++)
+	{
+		fputc((char)(dword >> 24), file);
+		dword <<= 8;
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Table extraction helper routines (inline 'em?)
+////////////////////////////////////////////////////////////////////////////
+
+//
+// Return a BYTE from a BYTE based table
+//
+uint8_t GetByte(uint8_t * table, uint32_t &ptr)
+{
+	return table[ptr++];
+}
+
+//
+// Return a WORD from a BYTE based table
+//
+uint16_t GetWord(uint8_t * table, uint32_t &ptr)
+{
+	uint16_t hi = table[ptr++];
+	uint16_t lo = table[ptr++];
+
+	return (uint16_t)((hi<<8) | lo);
+}
+
+//
+// Return a double WORD from a BYTE based table
+//
+uint32_t GetDWord(uint8_t * table, uint32_t &ptr)
+{
+	uint32_t hi1 = table[ptr++];
+	uint32_t lo1 = table[ptr++];
+	uint32_t hi2 = table[ptr++];
+	uint32_t lo2 = table[ptr++];
+
+	return (uint32_t)((hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Table storage helper routines (inline 'em?)
+////////////////////////////////////////////////////////////////////////////
+
+//
+// Store a BYTE in a BYTE based table
+//
+void SetByte(uint8_t * table, uint32_t &ptr, uint8_t data)
+{
+	table[ptr++] = data;
+}
+
+//
+// Store a WORD in a BYTE based table
+//
+void SetWord(uint8_t * table, uint32_t &ptr, uint16_t data)
+{
+	table[ptr++] = data>>8;  table[ptr++] = data&0xFF;
+}
+
+//
+// Store a DWORD in a BYTE based table
+//
+void SetDWord(uint8_t * table, uint32_t &ptr, uint32_t data)
+{
+	table[ptr++] = (uint8_t)(data >> 24); table[ptr++] = (uint8_t)(data >> 16);
+	table[ptr++] = (uint8_t)(data >> 8);  table[ptr++] = (uint8_t)(data & 0xFF);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Fixed point to float (& vice versa) conversions
+/////////////////////////////////////////////////////////////////////////////
+float FixedToFloat(int16_t fixed)
+{
+	return (float)fixed / 16384.0f;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// TTF Constructor
+/////////////////////////////////////////////////////////////////////////////
+TTF::TTF(void)
+{
+	loaded = false;								// Set font initializer
+	isDirty = false;							// Glyphs are clean
+	numberOfPolys = 0;							// Set reasonable values
+	isCompositeGlyph = false;					// No composite glyph (yet)
+
+	parray[0] = &EBDT;  parray[1] = &EBLC;  parray[2] = &EBSC; // Init pointer
+	parray[3] = &LTSH;  parray[4] = &OS_2;  parray[5] = &PCLT; // array...
+	parray[6] = &VDMX;  parray[7] = &cmap;  parray[8] = &cvt; 
+	parray[9] = &fpgm;  parray[10] = &gasp; parray[11] = &glyf;
+	parray[12] = &hdmx; parray[13] = &head; parray[14] = &hhea;
+	parray[15] = &hmtx; parray[16] = &kern; parray[17] = &loca;
+	parray[18] = &maxp; parray[19] = &name; parray[20] = &post;
+	parray[21] = &prep; parray[22] = &vhea; parray[23] = &vmtx;
+
+	larray[0] = &EBDT_len;  larray[1] = &EBLC_len;  larray[2] = &EBSC_len;
+	larray[3] = &LTSH_len;  larray[4] = &OS_2_len;  larray[5] = &PCLT_len;
+	larray[6] = &VDMX_len;  larray[7] = &cmap_len;  larray[8] = &cvt_len;
+	larray[9] = &fpgm_len;  larray[10] = &gasp_len; larray[11] = &glyf_len;
+	larray[12] = &hdmx_len; larray[13] = &head_len; larray[14] = &hhea_len;
+	larray[15] = &hmtx_len; larray[16] = &kern_len; larray[17] = &loca_len;
+	larray[18] = &maxp_len; larray[19] = &name_len; larray[20] = &post_len;
+	larray[21] = &prep_len; larray[22] = &vhea_len; larray[23] = &vmtx_len;
+
+	for(uint32_t i=0; i<NUMTABS; i++)
+		*parray[i] = NULL;						// Init pointers...
+
+	for(uint32_t i=0; i<MAXGLYPHS; i++)
+		glyph[i] = NULL;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// TTF Destructor
+/////////////////////////////////////////////////////////////////////////////
+TTF::~TTF()
+{
+	ClearTables();								// This should handle deallocation correctly...
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: void Init(void)
+//
+// This function initializes the TTF object, setting reasonable values for
+// the various internal variables used by the object.
+// [distinct from New?]
+/////////////////////////////////////////////////////////////////////////////
+void TTF::Init(void)
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Clear the tables so that file can be reloaded
+/////////////////////////////////////////////////////////////////////////////
+void TTF::ClearTables(void)
+{
+	for(uint32_t i=0; i<NUMTABS; i++)
+	{
+		if ((*parray[i]) != NULL)
+		{
+			free(*parray[i]);
+			*parray[i] = NULL;
+			*larray[i] = 0;
+		}
+	}  
+
+	for(uint32_t i=0; i<MAXGLYPHS; i++)
+	{
+		if (glyph[i] != NULL)
+		{
+			free(glyph[i]);
+			glyph[i] = NULL;
+		}
+	}
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL Load(const char * filename)
+//
+// This loads the TTF database from an external file.  Returns 'true' if
+// successful.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::Load(const char * filename)
+{
+//	unsigned char ch;							// Temp variable
+//	UINT num_tabs;								// Number of tables
+	uint32_t offset[NUMTABS], length[NUMTABS];	// Temporary storage...
+	char names[NUMTABS][5];
+	char narray[NUMTABS][5] = { "EBDT", "EBLC", "EBSC", "LTSH", "OS/2", "PCLT",
+		"VDMX", "cmap", "cvt ", "fpgm", "gasp", "glyf", "hdmx", "head", "hhea",
+		"hmtx", "kern", "loca", "maxp", "name", "post", "prep", "vhea", "vmtx" };
+
+	//loaded = false;
+//	file.open(filename, ios::binary|ios::in);	// Open the file
+	FILE * file = fopen(filename, "rb");
+
+	if (file == NULL)
+#ifdef TTFDEBUG
+{
+WriteLogMsg("Failed to open file!\n");
+#endif
+		return false;
+#ifdef TTFDEBUG
+}
+#endif
+
+	if (ReadDWord(file) != 0x00010000)
+#ifdef TTFDEBUG
+{
+WriteLogMsg("File was NOT a TTF file!\n");
+#endif
+		return false;							// Not a TTF file...
+#ifdef TTFDEBUG
+}
+#endif
+
+	uint32_t num_tabs = ReadWord(file);			// Get # of tables
+#ifdef TTFDEBUG
+WriteLogMsg("Number of tables is %u...\n", num_tabs);
+#endif
+//	fskip(file, 6);								// Skip this shiat...
+	fseek(file, 6, SEEK_CUR);
+
+#ifdef TTFDEBUG
+WriteLogMsg("Reading names of tables...\n");
+#endif
+	for(uint32_t i=0; i<num_tabs; i++)
+	{
+//		ReadFile(file, names[i], 4, &bytesRead, NULL);
+		fread(names[i], 1, 4, file);
+		names[i][4] = 0;
+//		fskip(file, 4);							// Checksum
+		fseek(file, 4, SEEK_CUR);				// Checksum
+		offset[i] = ReadDWord(file);			// Offset from start of file
+		length[i] = ReadDWord(file);			// Length of table
+	}
+
+#ifdef TTFDEBUG
+WriteLogMsg("Reading tables...\n");
+#endif
+	for(uint32_t i=0; i<num_tabs; i++)
+	{
+		for(uint32_t j=0; j<NUMTABS; j++)
+		{
+			if ((strcmp(names[i], narray[j])) == 0)	// Found a match...
+			{
+//				*parray[j] = (uint8_t *)GlobalAlloc(GMEM_FIXED, length[i]);	// Allocate space
+				*parray[j] = (uint8_t *)malloc(length[i]); // Alloc space
+
+				if (*parray[j] == NULL)
+					return false;				// Bail out if nothing allocated
+
+				*larray[j] = length[i];			// Set its length...
+//				SetFilePointer(file, (LONG)offset[i], NULL, FILE_BEGIN);
+//				ReadFile(file, *parray[j], length[i], &bytesRead, NULL);
+				fseek(file, offset[i], SEEK_SET);
+				fread(*parray[j], 1, length[i], file);
+				break;
+			}
+		}
+	}
+
+	fclose(file);
+
+// This shouldn't be necessary, since it's irrelevant (loaded flag)
+//    loaded = true;                       // Set 'loaded' flag...
+    isDirty = false;                     // Glyphs are clean
+    ExtractTables();                     // Move table data to my structs
+                                         // & ignore return val
+                                         // (should handle errors here)
+	return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL Save(const char * filename)
+//
+// Save the TT font currently in the object
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::Save(const char * filename)
+{
+//  fstream file;
+//	ULONG offset = 12;
+	uint32_t numtabs = 0;
+	char padding[3] = { 0, 0, 0 };
+	// Convert this to a table of ULONGs to decrease complexity...
+//wouldn't be endian safe then...
+	char narray[NUMTABS][5] = { "EBDT", "EBLC", "EBSC", "LTSH", "OS/2", "PCLT",
+		"VDMX", "cmap", "cvt ", "fpgm", "gasp", "glyf", "hdmx", "head", "hhea",
+		"hmtx", "kern", "loca", "maxp", "name", "post", "prep", "vhea", "vmtx" };
+
+	if (isDirty)
+		EncodeGlyph(currentGlyph);
+
+	BuildTables();								// Ignore return value...  
+
+	for(uint32_t i=0; i<NUMTABS; i++)				// Figure out how many tables there are
+		if ((*parray[i]) != NULL)
+			numtabs++;
+
+	uint32_t offset = 12 + (numtabs * 16);		// Calc correct offset to start of data
+
+//	HANDLE file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+//		NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+	FILE * file = fopen(filename, "wb");
+
+	WriteDWord(file, 0x00010000);				// Write header...
+	WriteWord(file, numtabs);
+	WriteWord(file, 0);							// SearchRange (Max power of 2 <= numTables) x 16.
+	WriteWord(file, 0);							// entrySelector Log2(max power of 2 <= numTables).
+	WriteWord(file, 0);							// NumTables x 16 - searchRange.
+
+	for(uint32_t i=0; i<NUMTABS; i++)					// Write out table directory...
+	{
+		if ((*parray[i]) != NULL)
+		{
+//			for(int j=0; j<4; j++)
+//				file.put(narray[i][j]);			// Name
+//			WriteFile(file, narray[i], 4, &bytesWritten, NULL);
+			fwrite(narray[i], 1, 4, file);		// Name
+
+			WriteDWord(file, 0);				// Checksum
+			WriteDWord(file, offset);			// Offset
+			WriteDWord(file, (*larray[i]));		// Length
+
+			offset += (((*larray[i]) + 3) & ~3);	// Pad out to 4-uint8_t boundary...
+		}
+	}
+
+	for(uint32_t i=0; i<NUMTABS; i++)					// Write out the tables...
+	{
+		if ((*parray[i]) != NULL)
+		{
+//			for(uint32_t j=0; j<(*larray[i]); j++)
+//				file.put((*parray[i])[j]);
+//			WriteFile(file, *parray[i], *larray[i], &bytesWritten, NULL);
+			fwrite(*parray[i], 1, *larray[i], file);
+
+			uint32_t remainder = ((*larray[i]) & 0x3);
+			if (remainder)               // i.e., it's not evenly div by 4
+//				for(j=remainder; j<4; j++)
+//					file.put((char)0);       // pad it!
+//				WriteFile(file, padding, 4 - remainder, &bytesWritten, NULL);
+				fwrite(padding, 1, 4 - remainder, file);
+		}
+	}
+
+	fclose(file);
+
+	return true;								// Whether or not it was successful...
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL EncodeGlyph(int glyphnum)
+//
+// This function encodes the glyph data and stores it to the 'glyf' table.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::EncodeGlyph(uint16_t glyphnum)
+{
+	bool retval = false;						// Assume failure
+	uint8_t flag, xbuf[4000], ybuf[4000], fbuf[2000];
+	uint32_t xp = 0, yp = 0, fp = 0;				// Table pointers
+
+	if (glyphnum < myMaxp.numGlyphs)  // numofgls is 1 based ind, glyph# 0 based
+	{
+		// need to add composite encoding...
+		int lastx = 0, lasty = 0;
+
+		for(uint32_t i=0; i<numberOfPoints; i++)
+		{
+			flag = 0;
+			int curx = gx[i] - lastx, cury = gy[i] - lasty;
+
+			if (onCurve[i])
+				flag |= 0x01;					// Set on curve info
+
+			if (curx)
+			{
+				if ((curx > 255) || (curx < -255)) // I.e., it's 2 uint8_t value
+					SetWord(xbuf, xp, curx);
+				else
+				{
+					if (curx & 0x100)
+					{
+						flag |= 0x02; // I.e., it's negative
+						curx *= -1;   // Flip it so correct value is stored
+					}
+					else
+						flag |= 0x12;
+
+					SetByte(xbuf, xp, curx);	// Automagically strips neg bit
+				}
+			}
+			else
+				flag |= 0x10;					// X-coord is same...
+  
+			if (cury)
+			{
+				if ((cury > 255) || (cury < -255)) // I.e., it's 2 uint8_t value
+					SetWord(ybuf, yp, cury);
+				else
+				{
+					if (cury & 0x100)
+					{
+						flag |= 0x04; // I.e., it's negative
+						cury *= -1;
+					}
+					else
+						flag |= 0x24;
+            
+					SetByte(ybuf, yp, cury);
+				}
+			}
+			else
+				flag |= 0x20;                 // Y-coord is same...
+  
+			fbuf[i] = flag;
+			lastx = gx[i];  lasty = gy[i];
+		}
+
+		// Now crunch flags...  ugly, ugly, ugly.
+/*
+    fbuf[numberOfPoints] = 0;  // Set sentinel value (ugly way to do this)
+    for(i=0; i<numberOfPoints; i++);
+    {
+      if (fbuf[i] == fbuf[i+1])  // 
+      {
+        uint8_t count = 0;  // Sentinel takes care of check for end of flags...
+        while (fbuf[i] == fbuf[++i])  count++; // Count number of repeats
+        i--;
+        fbuf[fp++] = fbuf[i] | 0x08; // Set repeat flag
+        fbuf[fp++] = count;          // & number of repeats
+      }
+      else  fbuf[fp++] = fbuf[i];    // Otherwise, just copy...
+    }
+*/
+		fp = numberOfPoints;
+		// Find length of glyph and reallocate space if necessary
+
+		uint32_t newLength = 12 + numberOfPolys*2 + numberOfHints + fp + xp + yp;
+
+		if (newLength & 0x03)
+			newLength += (4 - newLength & 0x03);
+
+		if (glyphLen[glyphnum] != newLength)
+		{
+			glyph[glyphnum] = (uint8_t *)realloc(glyph[glyphnum], newLength);
+			glyphLen[glyphnum] = newLength;
+		}
+
+		// And finally, store it!
+
+		uint32_t gp = 0;							// Glyph pointer...
+		SetWord(glyph[glyphnum], gp, numberOfPolys);
+		SetWord(glyph[glyphnum], gp, llx);
+		SetWord(glyph[glyphnum], gp, lly);
+		SetWord(glyph[glyphnum], gp, urx);
+		SetWord(glyph[glyphnum], gp, ury);
+		for(uint32_t i=0; i<numberOfPolys; i++)
+			SetWord(glyph[glyphnum], gp, poly[i]);
+		SetWord(glyph[glyphnum], gp, numberOfHints);
+		for(uint32_t i=0; i<numberOfHints; i++)
+			SetByte(glyph[glyphnum], gp, hint[i]);
+		for(uint32_t i=0; i<fp; i++)
+			SetByte(glyph[glyphnum], gp, fbuf[i]);
+		for(uint32_t i=0; i<xp; i++)
+			SetByte(glyph[glyphnum], gp, xbuf[i]);
+		for(uint32_t i=0; i<yp; i++)
+			SetByte(glyph[glyphnum], gp, ybuf[i]);
+
+		retval = true;							// Successfully encoded!
+	}
+
+	return retval;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL DecodeGlyph(int glyphnum)
+//
+// This function decodes the glyph data and stores it to the object's
+// internal array.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::DecodeGlyph(uint16_t glyphnum)
+{
+	bool retval = false;
+	uint32_t i, dp;
+
+	// glyphnum is 0 based index, while numGlyphs is 1 based
+	if (glyphnum >= myMaxp.numGlyphs)
+		return false;  // Invalid char #
+
+	if (!glyphLen[glyphnum])
+	{
+		numberOfPoints = numberOfPolys = 0;
+		return true;							// Zero length IS valid...
+	}
+//	else										// Get character data...
+//	{
+    // Now get the character data...
+	dp = 0;                     // Reset data pointer
+	isCompositeGlyph = false;   // Default is no
+	numberOfPolys = GetWord(glyph[glyphnum], dp);  // # of polygons
+
+	llx = (int16_t)GetWord(glyph[glyphnum], dp);           // Lower left X
+	lly = (int16_t)GetWord(glyph[glyphnum], dp);           // Lower left Y
+	urx = (int16_t)GetWord(glyph[glyphnum], dp);           // Upper right X
+	ury = (int16_t)GetWord(glyph[glyphnum], dp);           // Upper right Y
+
+	// Need to handle composite glyphs better here.  The ways things
+	// are set now is a recipe for disaster...
+
+	if (numberOfPolys == 0xFFFF)
+	{
+		isCompositeGlyph = true;
+		numberOfPolys = 0;						// Set for no points
+
+		Composite cmpst;
+
+		while (!compositeList.IsEmpty())		// Empty composite list...
+			compositeList.GetFront();
+
+		do
+		{
+			cmpst.flags = GetWord(glyph[glyphnum], dp);
+			cmpst.glyphIndex = GetWord(glyph[glyphnum], dp);
+			cmpst.arg1 = (cmpst.flags & 0x01 ? (int16_t)GetWord(glyph[glyphnum], dp) : (int8_t)GetByte(glyph[glyphnum], dp));
+			cmpst.arg2 = (cmpst.flags & 0x01 ? (int16_t)GetWord(glyph[glyphnum], dp) : (int8_t)GetByte(glyph[glyphnum], dp));
+
+			if (cmpst.flags & 0x08)
+				cmpst.xScale = cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
+			else if (cmpst.flags & 0x40)
+				cmpst.xScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
+			else if (cmpst.flags & 0x80)
+				cmpst.xScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.scale01 = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.scale10 = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
+
+			compositeList.AddAtRear(cmpst);
+		}
+		while (cmpst.flags & 0x20); //*/
+
+		return true;
+	}
+
+//do {
+//	USHORT flags;
+//	USHORT glyphIndex;
+//	if ( flags & ARG_1_AND_2_ARE_uint16_tS) {
+//	(SHORT or Fuint16_t) argument1;
+//	(SHORT or Fuint16_t) argument2;
+//	} else {
+//		USHORT arg1and2; /* (arg1 << 8) | arg2 */
+//	}
+//	if ( flags & WE_HAVE_A_SCALE ) {
+//		F2Dot14  scale;    /* Format 2.14 */
+//	} else if ( flags & WE_HAVE_AN_X_AND_Y_SCALE ) {
+//		F2Dot14  xscale;    /* Format 2.14 */
+//		F2Dot14  yscale;    /* Format 2.14 */
+//	} else if ( flags & WE_HAVE_A_TWO_BY_TWO ) {
+//		F2Dot14  xscale;    /* Format 2.14 */
+//		F2Dot14  scale01;   /* Format 2.14 */
+//		F2Dot14  scale10;   /* Format 2.14 */
+//		F2Dot14  yscale;    /* Format 2.14 */
+//	}
+//} while ( flags & MORE_COMPONENTS ) 
+//if (flags & WE_HAVE_INSTR){
+//	USHORT numInstr
+//	uint8_t instr[numInstr]
+//
+//Flags                    Bit     Description 
+//ARG_1_AND_2_ARE_uint16_tS    0       If this is set, the arguments are uint16_ts;
+//                                 otherwise, they are uint8_ts.
+//ARGS_ARE_XY_VALUES       1       If this is set, the arguments are xy values;
+//                                 otherwise, they are points.
+//ROUND_XY_TO_GRID         2       For the xy values if the preceding is true.
+//WE_HAVE_A_SCALE          3       This indicates that there is a simple scale
+//                                 for the component. Otherwise, scale = 1.0.
+//RESERVED                 4       This bit is reserved.  Set it to 0. 
+//MORE_COMPONENTS          5       Indicates at least one more glyph after this
+//                                 one.
+//WE_HAVE_AN_X_AND_Y_SCALE 6       The x direction will use a different scale
+//                                 from the y direction.
+//WE_HAVE_A_TWO_BY_TWO     7       There is a 2 by 2 transformation that will
+//                                 be used to scale the component.
+//WE_HAVE_INSTRUCTIONS     8       Following the last component are
+//                                 instructions for the composite character.
+//USE_MY_METRICS           9       If set, this forces the aw and lsb (and rsb)
+//                                 for the composite to be equal to those from
+//                                 this original glyph. This works for hinted
+//                                 and unhinted characters.
+
+	for(i=0; i<numberOfPolys; i++)
+		poly[i] = GetWord(glyph[glyphnum], dp);
+
+	numberOfHints = GetWord(glyph[glyphnum], dp);
+
+	for(i=0; i<numberOfHints; i++)
+		hint[i] = GetByte(glyph[glyphnum], dp);
+
+	// Decode the dots...
+
+	uint32_t num_pts = poly[numberOfPolys-1] + 1;
+	numberOfPoints = num_pts; // necessary??
+	uint32_t xptr, yptr;        // pointers to beginning of coord data
+	uint32_t numXs = 0;
+	int xx = 0, yy = 0, repeat;
+	uint32_t numTokens = num_pts, k, numRep;
+
+	// We make an educated guess that num_pts = num_tokens; but if there
+	// is repeated data in the tokens, then we need to adjust the # of
+	// tokens down appropriately.
+
+	for(uint32_t i=0; i<numTokens; i++)
+	{
+		uint8_t token = glyph[glyphnum][dp+i];  uint32_t rpts = 1;
+
+		if (token & 0x08)      // Repeated token?
+		{
+			i++;                 // Yes, bump pointer to # of times to repeat
+			numRep = glyph[glyphnum][dp+i];
+			rpts += numRep;
+
+			if (numRep > 1)      // Do we need to adjust numTokens?
+   // this is bad, modifying numTokens while it's used as a compare value
+   // in the above loop...
+   // Is it necessary to do so in order to keep from going too far?
+			numTokens -= (numRep - 1); // Yes, adjust.
+		}
+
+		// 10 = same x(0uint8_ts), 00 = 2uint8_ts, 02&12 = 1uint8_t
+		if ((token & 0x02) == 0x02)
+			numXs += rpts;
+
+		if ((token & 0x12) == 0x00)
+			numXs += (rpts*2);
+	}
+
+	xptr = dp + numTokens;
+	yptr = dp + numTokens + numXs;
+
+	// & continue decoding X/Y-coords...
+
+	k = 0;                               // Index to the point array
+
+	for(uint32_t i=0; i<numTokens; i++)
+	{
+		uint8_t token = glyph[glyphnum][dp+i];
+		repeat = 1;
+
+		if (token & 0x08)
+		{
+			i++;
+			repeat += glyph[glyphnum][dp+i]; // Set repeat data...
+		}
+
+		while (repeat--)
+		{
+			if ((token & 0x12) == 0x12)
+				xx += GetByte(glyph[glyphnum], xptr);
+
+			if ((token & 0x12) == 0x02)
+				xx -= GetByte(glyph[glyphnum], xptr);
+
+			if ((token & 0x12) == 0x00)
+				xx += (int16_t)GetWord(glyph[glyphnum], xptr);
+
+			gx[k] = xx;                      // Store x-coordinate
+
+			if ((token & 0x24) == 0x24)
+				yy += GetByte(glyph[glyphnum], yptr);
+
+			if ((token & 0x24) == 0x04)
+				yy -= GetByte(glyph[glyphnum], yptr);
+
+			if ((token & 0x24) == 0x00)
+				yy += (int16_t)GetWord(glyph[glyphnum], yptr);
+
+			gy[k] = yy;                      // Store y-coordinate
+
+			onCurve[k++] = (token & 0x01 ? true : false);  // If bit 0 set, then it's on curve
+		}
+	}
+
+	retval = true;							// Hmm. Successfully decoded a glyph...
+//	}
+
+	isDirty = false;  // do it here?
+
+	return retval;
+}
+
+/*****************************************************************************
+ Member function:
+
+ This function decodes the 'glyf' data for a non-composite (atomic) glyph and
+ returns it as a GlyphPoints object. Helper function.
+ *****************************************************************************/
+GlyphPoints TTF::GetGlyphPoints(uint16_t glyphNum)
+{
+	if (DecodeGlyph(glyphNum))
+		return GlyphPoints(numberOfPoints, numberOfPolys, gx, gy, onCurve, poly);
+
+	return GlyphPoints();
+}
+
+/*****************************************************************************
+ Member function:
+
+ This function decodes the 'glyf' data for a composite glyph and returns
+ it as a GlyphPoints object.
+ *****************************************************************************/
+GlyphPoints TTF::GetAllCompositePoints(uint16_t glyphNum)
+{
+//  int tmpGlyph = currentGlyph;
+  
+	DecodeGlyph(glyphNum);         // Check for composite-ness
+
+	if (!isCompositeGlyph)
+		return GlyphPoints();
+
+/*
+  for(int i=1; i<=pDoc->m_myFont.compositeList.Length(); i++)
+  {
+    TComposite cmpst = fnt->compositeList.PeekPosition(i);
+    fnt->SetGlyph(cmpst.glyphIndex);
+    if (cmpst.flags & 0x0002)
+      m_nXOffset = cmpst.arg1, m_nYOffset = cmpst.arg2;
+    ScanConvertSingleGlyph(pDC, nScanlines, nHorzLines, nXOffset, nYOffset);
+  }
+  fnt->SetGlyph(pDoc->character_num);
+*/
+
+	GlyphPoints retVal;
+
+	for(int i=1; i<=compositeList.Length(); i++)
+	{
+		Composite cmpst = compositeList.PeekPosition(i);
+    
+//    SetGlyph(cmpst.glyphIndex);
+//    if (cmpst.flags & 0x0002)
+//      m_nXOffset = cmpst.arg1, m_nYOffset = cmpst.arg2;
+//    ScanConvertSingleGlyph(pDC, nScanlines, nHorzLines, nXOffset, nYOffset);
+		GlyphPoints gp = GetGlyphPoints(cmpst.glyphIndex);
+
+		if (cmpst.flags & 0x0002)
+			gp.OffsetPoints(cmpst.arg1, cmpst.arg2);
+
+		retVal = retVal + gp;
+		// NOTE: May have to adjust scanlines as per 0x0002 above...
+	}
+
+//  SetGlyph(tmpGlyph);
+	DecodeGlyph(currentGlyph);     // Reset needed here...
+
+	return retVal;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: void GetCharName(int cNum, uint8_t * buf)
+//
+// This function returns the character name of the glyph number passed in.
+/////////////////////////////////////////////////////////////////////////////
+void TTF::GetCharName(int cNum, uint8_t * buf)
+{
+	buf[0] = 0;									// Set failure as default condition
+  
+	if (!post)									// PS names are here...
+		return;
+
+	if (post[1] != 0x02 || post[2] != 0x00)		// i.e., it's NOT a V2.0 table
+		return;
+
+	uint8_t * pTab = NULL;
+	uint32_t tabOff = 34, numGlyphs = (uint32_t)((post[32] << 8) | post[33]);
+	uint32_t index = (uint32_t)((post[tabOff + cNum * 2] << 8) | post[tabOff + cNum * 2 + 1]);
+	uint32_t nInd2;
+
+	if (index > 257)
+	{
+		index -= 258;
+		nInd2 = tabOff + (2 * numGlyphs);
+		pTab = post;
+	}
+	else
+	{
+		nInd2 = 0;
+		pTab = macStdNames;
+	}
+
+	for(uint32_t i=0; i<index; i++)
+		nInd2 = nInd2 + pTab[nInd2] + 1; // 1st uint8_t is length of string + that uint8_t
+
+	uint8_t len = pTab[nInd2];
+	nInd2++;
+
+	for(uint8_t i=0; i<len; i++)
+		buf[i] = pTab[nInd2 + i];
+
+	buf[len] = 0;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL ExtractTables(void)
+//
+// This function extracts the data from the various tables and puts them in
+// various structs for easier handling of the font data.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::ExtractTables(void)
+{
+	if (head_len != 54)
+	{
+#ifdef TTFDEBUG
+WriteLogMsg("Bad HEAD header: Expected 54, found %u...\n", head_len);
+#endif
+		return false;							// Corrupt data?
+	}
+
+	uint32_t tp = 0;
+	myHead.version            = GetDWord(head, tp);
+	myHead.fontRevision       = GetDWord(head, tp);
+	myHead.checkSumAdjustment = GetDWord(head, tp);
+	myHead.magicNumber        = GetDWord(head, tp);
+	myHead.flags              = GetWord(head, tp);
+	myHead.unitsPerEm         = GetWord(head, tp);
+	myHead.createdh           = GetDWord(head, tp);
+	myHead.createdl           = GetDWord(head, tp);
+	myHead.modifiedh          = GetDWord(head, tp);
+	myHead.modifiedl          = GetDWord(head, tp);
+	myHead.xMin               = GetWord(head, tp);
+	myHead.yMin               = GetWord(head, tp);
+	myHead.xMax               = GetWord(head, tp);
+	myHead.yMax               = GetWord(head, tp);
+	myHead.macStyle           = GetWord(head, tp);
+	myHead.lowestRecPPEM      = GetWord(head, tp);
+	myHead.fontDirectionHint  = (int16_t)GetWord(head, tp);
+	myHead.indexToLocFormat   = (int16_t)GetWord(head, tp);
+	myHead.glyphDataFormat    = (int16_t)GetWord(head, tp);
+
+	if (maxp_len != 32)
+	{
+#ifdef TDEBUG
+WriteLogMsg("Bad MAXP header: Expected 32, found %u...\n", maxp_len);
+#endif
+		return false;							// Corrupt data?
+	}
+
+	tp = 0;										// Reset table pointer
+	myMaxp.version               = GetDWord(maxp, tp);
+	myMaxp.numGlyphs             = GetWord(maxp, tp);
+	myMaxp.maxPoints             = GetWord(maxp, tp);
+	myMaxp.maxContours           = GetWord(maxp, tp);
+	myMaxp.maxCompositePoints    = GetWord(maxp, tp);
+	myMaxp.maxCompositeContours  = GetWord(maxp, tp);
+	myMaxp.maxZones              = GetWord(maxp, tp);
+	myMaxp.maxTwilightPoints     = GetWord(maxp, tp);
+	myMaxp.maxStorage            = GetWord(maxp, tp);
+	myMaxp.maxFunctionDefs       = GetWord(maxp, tp);
+	myMaxp.maxInstructionDefs    = GetWord(maxp, tp);
+	myMaxp.maxStackElements      = GetWord(maxp, tp);
+	myMaxp.maxSizeOfInstructions = GetWord(maxp, tp);
+	myMaxp.maxComponentElements  = GetWord(maxp, tp);
+	myMaxp.maxComponentDepth     = GetWord(maxp, tp);
+
+	tp = 0;										// Reset table pointer
+	uint32_t start = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
+
+	for(uint32_t i=0; i<myMaxp.numGlyphs; i++)
+	{
+		uint32_t end = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
+		uint32_t length = end - start;
+		glyphLen[i] = length;					// Lengths are saved 'cause malloc is sloppy
+
+		if (length)     // loca+start? pointer arithmetic?
+		{
+			glyph[i] = (uint8_t *)malloc(length);	// Allocate space,
+			memcpy(glyph[i], glyf+start, length);	// and move it!
+		}
+		else
+			glyph[i] = NULL;
+
+		start = end;							// Reset start value
+	}
+
+	return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL BuildTables(void)
+//
+// This function builds the various TTF tables using info in the various
+// structs so that a TTF file can be written out to disk.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::BuildTables(void)
+{
+	uint32_t i, tp, start;
+
+	myHead.indexToLocFormat = 1;				// We don't bother with [uint16_ts*2] format...
+
+	// Build HEAD table
+
+	tp = 0;										// Reset table pointer
+	SetDWord(head, tp, myHead.version);//            = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.fontRevision);//       = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.checkSumAdjustment);// = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.magicNumber);//        = GetDWord(head, tp);
+	SetWord(head, tp, myHead.flags);//              = GetWord(head, tp);
+	SetWord(head, tp, myHead.unitsPerEm);//         = GetWord(head, tp);
+	SetDWord(head, tp, myHead.createdh);//           = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.createdl);//           = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.modifiedh);//          = GetDWord(head, tp);
+	SetDWord(head, tp, myHead.modifiedl);//          = GetDWord(head, tp);
+	SetWord(head, tp, myHead.xMin);//               = GetWord(head, tp);
+	SetWord(head, tp, myHead.yMin);//               = GetWord(head, tp);
+	SetWord(head, tp, myHead.xMax);//               = GetWord(head, tp);
+	SetWord(head, tp, myHead.yMax);//               = GetWord(head, tp);
+	SetWord(head, tp, myHead.macStyle);//           = GetWord(head, tp);
+	SetWord(head, tp, myHead.lowestRecPPEM);//      = GetWord(head, tp);
+	SetWord(head, tp, myHead.fontDirectionHint);//  = (int16_t)GetWord(head, tp);
+	SetWord(head, tp, myHead.indexToLocFormat);//   = (int16_t)GetWord(head, tp);
+	SetWord(head, tp, myHead.glyphDataFormat);//    = (int16_t)GetWord(head, tp);
+
+	// Build MAXP table
+
+	tp = 0;										// Reset table pointer
+	SetDWord(maxp, tp, myMaxp.version);//               = GetDWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.numGlyphs);//             = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxPoints);//             = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxContours);//           = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxCompositePoints);//    = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxCompositeContours);//  = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxZones);//              = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxTwilightPoints);//     = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxStorage);//            = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxFunctionDefs);//       = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxInstructionDefs);//    = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxStackElements);//      = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxSizeOfInstructions);// = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxComponentElements);//  = GetWord(maxp, tp);
+	SetWord(maxp, tp, myMaxp.maxComponentDepth);//     = GetWord(maxp, tp);
+
+	// Build LOCA & GLYF tables
+
+	loca_len = (myMaxp.numGlyphs+1) * 4;		// Set size of table
+
+	if (loca)
+		free(loca);								// And create/reallocate it...
+
+	loca = (uint8_t *) malloc(loca_len);
+
+	glyf_len = 0;								// Refigure glyf table length
+
+	for(i=0; i<myMaxp.numGlyphs; i++)
+		glyf_len += glyphLen[i];
+
+	if (glyf)
+		free(glyf);
+
+	glyf = (uint8_t *) malloc(glyf_len);
+
+	start = tp = 0;								// Reset table pointer
+
+	for(i=0; i<myMaxp.numGlyphs; i++)
+	{
+		SetDWord(loca, tp, start);				// Store glyph start address
+
+		if (glyphLen[i])
+			memcpy(glyf+start, glyph[i], glyphLen[i]);
+
+		start += glyphLen[i];
+	}
+
+	SetDWord(loca, tp, start);					// Finally, store end of glyphs+1
+
+	return true;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL SetGlyph(int glyphnum)
+//
+// This function decodes the glyph data and stores the points in its own
+// internal array.  If the flag isDirty is set, it also encodes the internal
+// array and stores it to the 'glyf' table.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::SetGlyph(uint16_t glyphnum)
+{
+	bool retval = false;						// Set failure as default
+
+	if (isDirty)
+		EncodeGlyph(currentGlyph);
+
+	isDirty = false;
+
+	if (glyphnum < myMaxp.numGlyphs)			// numofgls is 1 based ind, glyph# 0 based
+	{
+		currentGlyph = glyphnum;
+		DecodeGlyph(currentGlyph);
+		retval = true;
+	}
+
+	return retval;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL AddGlyph(int glyphnum)
+//
+// This function adds a glyph of zero size at position glyphnum.  If glyphnum
+// is greater than the number of glyphs, glyph is added at end of list. This
+// glyph then becomes the current glyph.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::AddGlyph(uint16_t glyphnum)
+{
+	// incomplete: JLH
+	bool retval = false;
+
+	if (isDirty)
+		EncodeGlyph(currentGlyph);
+
+	isDirty = false;
+
+	return retval;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Member function: BOOL DeleteGlyph(int glyphnum)
+//
+// This function deletes the glyph at position glyphnum.  All glyphs after
+// this glyph are moved down in position.
+/////////////////////////////////////////////////////////////////////////////
+bool TTF::DeleteGlyph(uint16_t glyphnum)
+{
+	// incomplete: JLH
+	bool retval = false;
+
+	return retval;
+}
+
+//
+// Various & sundry member functions implementation
+//
+// NOTE: For error handling, should throw exceptions--not return values...! !!! FIX !!!
+//
+
+Box TTF::GetBoundingBox(void)
+{
+	return Box(llx, lly, urx, ury);
+}
+
+GlyphPt TTF::GetPoint(uint16_t pointno)
+{
+	GlyphPt p;
+
+	if (pointno >= MAXPOINTS)
+		return p; // Fix to make invalid
+
+	p.x = gx[pointno], p.y = gy[pointno], p.onCurve = onCurve[pointno];
+	return p;
+}
+
+uint16_t TTF::GetNumberOfPolys(void)
+{
+	return numberOfPolys;
+}
+
+uint16_t TTF::GetPolyEnd(uint16_t polynum)
+{
+	if (polynum >= numberOfPolys)
+		return 0;
+
+	return poly[polynum];
+}
+
+int TTF::GetPointX(uint16_t pointno)
+{
+	if (pointno >= MAXPOINTS)
+		return 0;
+
+	return gx[pointno];
+}
+
+int TTF::GetPointY(uint16_t pointno)
+{
+	if (pointno >= MAXPOINTS)
+		return 0;
+
+	return gy[pointno];
+}
+
+bool TTF::GetOnCurve(uint16_t pointno)
+{
+	if (pointno >= MAXPOINTS)
+		return true;
+
+	return onCurve[pointno];
+}
+
+bool TTF::SetOnCurve(uint16_t pointno, bool state)
+{
+	if (pointno >= numberOfPoints)
+		return false;
+
+	onCurve[pointno] = state;
+	isDirty = true;
+
+	return true;
+}
+
+bool TTF::MovePoint(uint16_t pointno, int x, int y)
+{
+	if (pointno >= numberOfPoints)
+		return false;
+
+	gx[pointno] = x;  gy[pointno] = y;
+	isDirty = true;
+
+	return true;
+}
+
+bool TTF::MovePoint(uint16_t pointno, GlyphPt p)
+{
+	if (pointno >= numberOfPoints)
+		return false;
+
+	gx[pointno] = p.x;  gy[pointno] = p.y;  onCurve[pointno] = p.onCurve;
+	isDirty = true;
+
+	return true;
+}
+
+bool TTF::IsCompositeGlyph(void)
+{
+	return isCompositeGlyph;
+}
+