source/test/letest/PortableFontInstance.cpp - external/github.com/unicode-org/icu - Git at Google

 /*
  *******************************************************************************
  *
  *   Copyright (C) 1999-2013, International Business Machines
  *   Corporation and others.  All Rights Reserved.
  *
  *******************************************************************************
  *   file name:  PortableFontInstance.cpp
  *
  *   created on: 11/22/1999
  *   created by: Eric R. Mader
  */

 #include <stdio.h>

 #include "layout/LETypes.h"
 #include "layout/LEFontInstance.h"
 #include "layout/LESwaps.h"

 #include "PortableFontInstance.h"

 //#include "letest.h"
 #include "sfnt.h"

 #include <string.h>
 #include <stdio.h>

 #if 0
 static const char *letagToStr(LETag tag, char *str) {
   str[0]= 0xFF & (tag>>24);
   str[1]= 0xFF & (tag>>16);
   str[2]= 0xFF & (tag>>8);
   str[3]= 0xFF & (tag>>0);
   str[4]= 0;
   return str;
 }
 #endif

 //
 // Finds the high bit by binary searching
 // through the bits in n.
 //
 le_int8 PortableFontInstance::highBit(le_int32 value)
 {
     if (value <= 0) {
         return -32;
     }

     le_uint8 bit = 0;

     if (value >= 1 << 16) {
         value >>= 16;
         bit += 16;
     }

     if (value >= 1 << 8) {
         value >>= 8;
         bit += 8;
     }

     if (value >= 1 << 4) {
         value >>= 4;
         bit += 4;
     }

     if (value >= 1 << 2) {
         value >>= 2;
         bit += 2;
     }

     if (value >= 1 << 1) {
         value >>= 1;
         bit += 1;
     }

     return bit;
 }

 PortableFontInstance::PortableFontInstance(const char *fileName, float pointSize, LEErrorCode &status)
     : fFile(NULL), fPointSize(pointSize), fUnitsPerEM(0), fFontChecksum(0), fAscent(0), fDescent(0), fLeading(0),
       fDirectory(NULL), fNAMETable(NULL), fNameCount(0), fNameStringOffset(0), fCMAPMapper(NULL), fHMTXTable(NULL), fNumGlyphs(0), fNumLongHorMetrics(0)
 {
     if (LE_FAILURE(status)) {
         return;
     }

     // open the font file
     fFile = fopen(fileName, "rb");
     //printf("Open Font: %s\n", fileName);

     if (fFile == NULL) {
         printf("%s:%d: %s: FNF\n", __FILE__, __LINE__, fileName);
         status = LE_FONT_FILE_NOT_FOUND_ERROR;
         return;
     }

     // read in the directory
     SFNTDirectory tempDir;

     fread(&tempDir, sizeof tempDir, 1, fFile);

     le_int32 dirSize = sizeof tempDir + ((SWAPW(tempDir.numTables) - ANY_NUMBER) * sizeof(DirectoryEntry));
     const LETag headTag = LE_HEAD_TABLE_TAG;
     const LETag hheaTag = LE_HHEA_TABLE_TAG;
     const HEADTable *headTable = NULL;
     const HHEATable *hheaTable = NULL;
 //  const NAMETable *nameTable = NULL;
     le_uint16 numTables = 0;

     fDirectory = (const SFNTDirectory *) LE_NEW_ARRAY(char, dirSize);

     if (fDirectory == NULL) {
         printf("%s:%d: %s: malloc err\n", __FILE__, __LINE__, fileName);
         status = LE_MEMORY_ALLOCATION_ERROR;
         goto error_exit;
     }

     fseek(fFile, 0L, SEEK_SET);
     fread((void *) fDirectory, sizeof(char), dirSize, fFile);

     //
     // We calculate these numbers 'cause some fonts
     // have bogus values for them in the directory header.
     //
     numTables = SWAPW(fDirectory->numTables);
     fDirPower = 1 << highBit(numTables);
     fDirExtra = numTables - fDirPower;

     // read unitsPerEm from 'head' table
     headTable = (const HEADTable *) readFontTable(headTag);

     if (headTable == NULL) {
         status = LE_MISSING_FONT_TABLE_ERROR;
         printf("%s:%d: %s: missing head table\n", __FILE__, __LINE__, fileName);
         goto error_exit;
     }

     fUnitsPerEM   = SWAPW(headTable->unitsPerEm);
     fFontChecksum = SWAPL(headTable->checksumAdjustment);
     freeFontTable(headTable);

     //nameTable = (NAMETable *) readFontTable(nameTag);

     //if (nameTable == NULL) {
     //    status = LE_MISSING_FONT_TABLE_ERROR;
     //    goto error_exit;
     //}

     //fFontVersionString = findName(nameTable, NAME_VERSION_STRING, PLATFORM_MACINTOSH, MACINTOSH_ROMAN, MACINTOSH_ENGLISH);

     //if (fFontVersionString == NULL) {
     //    status = LE_MISSING_FONT_TABLE_ERROR;
     //    goto error_exit;
     //}

     //freeFontTable(nameTable);

     hheaTable = (HHEATable *) readFontTable(hheaTag);

     if (hheaTable == NULL) {
         printf("%s:%d: %s: missing hhea table\n", __FILE__, __LINE__, fileName);
         status = LE_MISSING_FONT_TABLE_ERROR;
         goto error_exit;
     }

     fAscent  = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));
     fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));
     fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));

     fNumLongHorMetrics = SWAPW(hheaTable->numOfLongHorMetrics);

     freeFontTable((void *) hheaTable);

     fCMAPMapper = findUnicodeMapper();

     if (fCMAPMapper == NULL) {
         printf("%s:%d: %s: can't load cmap\n", __FILE__, __LINE__, fileName);
         status = LE_MISSING_FONT_TABLE_ERROR;
         goto error_exit;
     }

     return;

 error_exit:
     fclose(fFile);
     fFile = NULL;
     return;
 }

 PortableFontInstance::~PortableFontInstance()
 {
     if (fFile != NULL) {
         fclose(fFile);

         freeFontTable(fHMTXTable);
         freeFontTable(fNAMETable);

         delete fCMAPMapper;

         LE_DELETE_ARRAY(fDirectory);
     }
 }

 const DirectoryEntry *PortableFontInstance::findTable(LETag tag) const
 {
     if (fDirectory != NULL) {
         le_uint16 table = 0;
         le_uint16 probe = fDirPower;

         if (SWAPL(fDirectory->tableDirectory[fDirExtra].tag) <= tag) {
             table = fDirExtra;
         }

         while (probe > (1 << 0)) {
             probe >>= 1;

             if (SWAPL(fDirectory->tableDirectory[table + probe].tag) <= tag) {
                 table += probe;
             }
         }

         if (SWAPL(fDirectory->tableDirectory[table].tag) == tag) {
             return &fDirectory->tableDirectory[table];
         }
     }

     return NULL;
 }

 const void *PortableFontInstance::readTable(LETag tag, le_uint32 *length) const
 {
     const DirectoryEntry *entry = findTable(tag);

     if (entry == NULL) {
         *length = 0;
         return NULL;
     }

     *length = SWAPL(entry->length);

     void *table = LE_NEW_ARRAY(char, *length);

     if (table != NULL) {
         fseek(fFile, SWAPL(entry->offset), SEEK_SET);
         fread(table, sizeof(char), *length, fFile);
     }

     return table;
 }

 const void *PortableFontInstance::getFontTable(LETag tableTag) const
 {
   size_t ignored;
   return getFontTable(tableTag, ignored);
 }

 const void *PortableFontInstance::getFontTable(LETag tableTag, size_t &length) const
 {
   return FontTableCache::find(tableTag, length);
 }

 const void *PortableFontInstance::readFontTable(LETag tableTag, size_t &length) const
 {
     le_uint32 len;

     const void *data= readTable(tableTag, &len);
     length = len;
     //char tag5[5];
     //printf("Read %s, result %p #%d\n", letagToStr(tableTag,tag5), data,len);
     return data;
 }

 CMAPMapper *PortableFontInstance::findUnicodeMapper()
 {
     LETag cmapTag = LE_CMAP_TABLE_TAG;
     const CMAPTable *cmap = (CMAPTable *) readFontTable(cmapTag);

     if (cmap == NULL) {
         return NULL;
     }

     return CMAPMapper::createUnicodeMapper(cmap);
 }

 const char *PortableFontInstance::getNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
 {
     if (fNAMETable == NULL) {
         LETag nameTag = LE_NAME_TABLE_TAG;
         PortableFontInstance *realThis = (PortableFontInstance *) this;

         realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);

         if (realThis->fNAMETable != NULL) {
             realThis->fNameCount        = SWAPW(realThis->fNAMETable->count);
             realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
         }
     }

     for(le_int32 i = 0; i < fNameCount; i += 1) {
         const NameRecord *nameRecord = &fNAMETable->nameRecords[i];

         if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
             SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
             char *name = ((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset);
             le_uint16 length = SWAPW(nameRecord->length);
             char *result = LE_NEW_ARRAY(char, length + 2);

             LE_ARRAY_COPY(result, name, length);
             result[length] = result[length + 1] = 0;

             return result;
         }
     }

     return NULL;
 }

 const LEUnicode16 *PortableFontInstance::getUnicodeNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
 {
     if (fNAMETable == NULL) {
         LETag nameTag = LE_NAME_TABLE_TAG;
         PortableFontInstance *realThis = (PortableFontInstance *) this;

         realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);

         if (realThis->fNAMETable != NULL) {
             realThis->fNameCount        = SWAPW(realThis->fNAMETable->count);
             realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
         }
     }

     for(le_int32 i = 0; i < fNameCount; i += 1) {
         const NameRecord *nameRecord = &fNAMETable->nameRecords[i];

         if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
             SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
             LEUnicode16 *name = (LEUnicode16 *) (((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset));
             le_uint16 length = SWAPW(nameRecord->length) / 2;
             LEUnicode16 *result = LE_NEW_ARRAY(LEUnicode16, length + 2);

             for (le_int32 c = 0; c < length; c += 1) {
                 result[c] = SWAPW(name[c]);
             }

             result[length] = 0;

             return result;
         }
     }

     return NULL;
 }

 void PortableFontInstance::deleteNameString(const char *name) const
 {
     LE_DELETE_ARRAY(name);
 }

 void PortableFontInstance::deleteNameString(const LEUnicode16 *name) const
 {
     LE_DELETE_ARRAY(name);
 }

 void PortableFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
 {
     TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph);

     if (fHMTXTable == NULL) {
         LETag maxpTag = LE_MAXP_TABLE_TAG;
         LETag hmtxTag = LE_HMTX_TABLE_TAG;
         const MAXPTable *maxpTable = (MAXPTable *) readFontTable(maxpTag);
         PortableFontInstance *realThis = (PortableFontInstance *) this;

         if (maxpTable != NULL) {
             realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs);
             freeFontTable(maxpTable);
         }

         realThis->fHMTXTable = (const HMTXTable *) readFontTable(hmtxTag);
     }

     le_uint16 index = ttGlyph;

     if (ttGlyph >= fNumGlyphs || fHMTXTable == NULL) {
         advance.fX = advance.fY = 0;
         return;
     }

     if (ttGlyph >= fNumLongHorMetrics) {
         index = fNumLongHorMetrics - 1;
     }

     advance.fX = xUnitsToPoints(SWAPW(fHMTXTable->hMetrics[index].advanceWidth));
     advance.fY = 0;
 }

 le_bool PortableFontInstance::getGlyphPoint(LEGlyphID /*glyph*/, le_int32 /*pointNumber*/, LEPoint &/*point*/) const
 {
     return FALSE;
 }

 le_int32 PortableFontInstance::getUnitsPerEM() const
 {
     return fUnitsPerEM;
 }

 le_uint32 PortableFontInstance::getFontChecksum() const
 {
     return fFontChecksum;
 }

 le_uint32 PortableFontInstance::getRawChecksum() const
 {
   // how big is it?
   //  fseek(fFile, 0L, SEEK_END);
   //  long size = ftell(fFile);
   le_int32 chksum = 0;
   // now, calculate
   fseek(fFile, 0L, SEEK_SET);
   int r;
   int count =0;
   while((r = fgetc(fFile)) != EOF) {
     chksum += r;
     count ++;
   }
   return (le_uint32) chksum; // cast to signed
 }

 le_int32 PortableFontInstance::getAscent() const
 {
     return fAscent;
 }

 le_int32 PortableFontInstance::getDescent() const
 {
     return fDescent;
 }

 le_int32 PortableFontInstance::getLeading() const
 {
     return fLeading;
 }

 // We really want to inherit this method from the superclass, but some compilers
 // issue a warning if we don't implement it...
 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const
 {
     return LEFontInstance::mapCharToGlyph(ch, mapper, filterZeroWidth);
 }

 // We really want to inherit this method from the superclass, but some compilers
 // issue a warning if we don't implement it...
 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const
 {
     return LEFontInstance::mapCharToGlyph(ch, mapper);
 }

 LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch) const
 {
     return fCMAPMapper->unicodeToGlyph(ch);
 }

 float PortableFontInstance::getXPixelsPerEm() const
 {
     return fPointSize;
 }

 float PortableFontInstance::getYPixelsPerEm() const
 {
     return fPointSize;
 }

 float PortableFontInstance::getScaleFactorX() const
 {
     return 1.0;
 }

 float PortableFontInstance::getScaleFactorY() const
 {
     return 1.0;
 }
	/*
	*******************************************************************************
	*
	* Copyright (C) 1999-2013, International Business Machines
	* Corporation and others. All Rights Reserved.
	*
	*******************************************************************************
	* file name: PortableFontInstance.cpp
	*
	* created on: 11/22/1999
	* created by: Eric R. Mader
	*/

	#include <stdio.h>

	#include "layout/LETypes.h"
	#include "layout/LEFontInstance.h"
	#include "layout/LESwaps.h"

	#include "PortableFontInstance.h"

	//#include "letest.h"
	#include "sfnt.h"

	#include <string.h>
	#include <stdio.h>

	#if 0
	static const char letagToStr(LETag tag, char str) {
	str[0]= 0xFF & (tag>>24);
	str[1]= 0xFF & (tag>>16);
	str[2]= 0xFF & (tag>>8);
	str[3]= 0xFF & (tag>>0);
	str[4]= 0;
	return str;
	}
	#endif

	//
	// Finds the high bit by binary searching
	// through the bits in n.
	//
	le_int8 PortableFontInstance::highBit(le_int32 value)
	{
	if (value <= 0) {
	return -32;
	}

	le_uint8 bit = 0;

	if (value >= 1 << 16) {
	value >>= 16;
	bit += 16;
	}

	if (value >= 1 << 8) {
	value >>= 8;
	bit += 8;
	}

	if (value >= 1 << 4) {
	value >>= 4;
	bit += 4;
	}

	if (value >= 1 << 2) {
	value >>= 2;
	bit += 2;
	}

	if (value >= 1 << 1) {
	value >>= 1;
	bit += 1;
	}

	return bit;
	}

	PortableFontInstance::PortableFontInstance(const char *fileName, float pointSize, LEErrorCode &status)
	: fFile(NULL), fPointSize(pointSize), fUnitsPerEM(0), fFontChecksum(0), fAscent(0), fDescent(0), fLeading(0),
	fDirectory(NULL), fNAMETable(NULL), fNameCount(0), fNameStringOffset(0), fCMAPMapper(NULL), fHMTXTable(NULL), fNumGlyphs(0), fNumLongHorMetrics(0)
	{
	if (LE_FAILURE(status)) {
	return;
	}

	// open the font file
	fFile = fopen(fileName, "rb");
	//printf("Open Font: %s\n", fileName);

	if (fFile == NULL) {
	printf("%s:%d: %s: FNF\n", __FILE__, __LINE__, fileName);
	status = LE_FONT_FILE_NOT_FOUND_ERROR;
	return;
	}

	// read in the directory
	SFNTDirectory tempDir;

	fread(&tempDir, sizeof tempDir, 1, fFile);

	le_int32 dirSize = sizeof tempDir + ((SWAPW(tempDir.numTables) - ANY_NUMBER) * sizeof(DirectoryEntry));
	const LETag headTag = LE_HEAD_TABLE_TAG;
	const LETag hheaTag = LE_HHEA_TABLE_TAG;
	const HEADTable *headTable = NULL;
	const HHEATable *hheaTable = NULL;
	// const NAMETable *nameTable = NULL;
	le_uint16 numTables = 0;

	fDirectory = (const SFNTDirectory *) LE_NEW_ARRAY(char, dirSize);

	if (fDirectory == NULL) {
	printf("%s:%d: %s: malloc err\n", __FILE__, __LINE__, fileName);
	status = LE_MEMORY_ALLOCATION_ERROR;
	goto error_exit;
	}

	fseek(fFile, 0L, SEEK_SET);
	fread((void *) fDirectory, sizeof(char), dirSize, fFile);

	//
	// We calculate these numbers 'cause some fonts
	// have bogus values for them in the directory header.
	//
	numTables = SWAPW(fDirectory->numTables);
	fDirPower = 1 << highBit(numTables);
	fDirExtra = numTables - fDirPower;

	// read unitsPerEm from 'head' table
	headTable = (const HEADTable *) readFontTable(headTag);

	if (headTable == NULL) {
	status = LE_MISSING_FONT_TABLE_ERROR;
	printf("%s:%d: %s: missing head table\n", __FILE__, __LINE__, fileName);
	goto error_exit;
	}

	fUnitsPerEM = SWAPW(headTable->unitsPerEm);
	fFontChecksum = SWAPL(headTable->checksumAdjustment);
	freeFontTable(headTable);

	//nameTable = (NAMETable *) readFontTable(nameTag);

	//if (nameTable == NULL) {
	// status = LE_MISSING_FONT_TABLE_ERROR;
	// goto error_exit;
	//}

	//fFontVersionString = findName(nameTable, NAME_VERSION_STRING, PLATFORM_MACINTOSH, MACINTOSH_ROMAN, MACINTOSH_ENGLISH);

	//if (fFontVersionString == NULL) {
	// status = LE_MISSING_FONT_TABLE_ERROR;
	// goto error_exit;
	//}

	//freeFontTable(nameTable);

	hheaTable = (HHEATable *) readFontTable(hheaTag);

	if (hheaTable == NULL) {
	printf("%s:%d: %s: missing hhea table\n", __FILE__, __LINE__, fileName);
	status = LE_MISSING_FONT_TABLE_ERROR;
	goto error_exit;
	}

	fAscent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));
	fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));
	fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));

	fNumLongHorMetrics = SWAPW(hheaTable->numOfLongHorMetrics);

	freeFontTable((void *) hheaTable);

	fCMAPMapper = findUnicodeMapper();

	if (fCMAPMapper == NULL) {
	printf("%s:%d: %s: can't load cmap\n", __FILE__, __LINE__, fileName);
	status = LE_MISSING_FONT_TABLE_ERROR;
	goto error_exit;
	}

	return;

	error_exit:
	fclose(fFile);
	fFile = NULL;
	return;
	}

	PortableFontInstance::~PortableFontInstance()
	{
	if (fFile != NULL) {
	fclose(fFile);

	freeFontTable(fHMTXTable);
	freeFontTable(fNAMETable);

	delete fCMAPMapper;

	LE_DELETE_ARRAY(fDirectory);
	}
	}

	const DirectoryEntry *PortableFontInstance::findTable(LETag tag) const
	{
	if (fDirectory != NULL) {
	le_uint16 table = 0;
	le_uint16 probe = fDirPower;

	if (SWAPL(fDirectory->tableDirectory[fDirExtra].tag) <= tag) {
	table = fDirExtra;
	}

	while (probe > (1 << 0)) {
	probe >>= 1;

	if (SWAPL(fDirectory->tableDirectory[table + probe].tag) <= tag) {
	table += probe;
	}
	}

	if (SWAPL(fDirectory->tableDirectory[table].tag) == tag) {
	return &fDirectory->tableDirectory[table];
	}
	}

	return NULL;
	}

	const void PortableFontInstance::readTable(LETag tag, le_uint32 length) const
	{
	const DirectoryEntry *entry = findTable(tag);

	if (entry == NULL) {
	*length = 0;
	return NULL;
	}

	*length = SWAPL(entry->length);

	void table = LE_NEW_ARRAY(char, length);

	if (table != NULL) {
	fseek(fFile, SWAPL(entry->offset), SEEK_SET);
	fread(table, sizeof(char), *length, fFile);
	}

	return table;
	}

	const void *PortableFontInstance::getFontTable(LETag tableTag) const
	{
	size_t ignored;
	return getFontTable(tableTag, ignored);
	}

	const void *PortableFontInstance::getFontTable(LETag tableTag, size_t &length) const
	{
	return FontTableCache::find(tableTag, length);
	}

	const void *PortableFontInstance::readFontTable(LETag tableTag, size_t &length) const
	{
	le_uint32 len;

	const void *data= readTable(tableTag, &len);
	length = len;
	//char tag5[5];
	//printf("Read %s, result %p #%d\n", letagToStr(tableTag,tag5), data,len);
	return data;
	}

	CMAPMapper *PortableFontInstance::findUnicodeMapper()
	{
	LETag cmapTag = LE_CMAP_TABLE_TAG;
	const CMAPTable cmap = (CMAPTable ) readFontTable(cmapTag);

	if (cmap == NULL) {
	return NULL;
	}

	return CMAPMapper::createUnicodeMapper(cmap);
	}

	const char *PortableFontInstance::getNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
	{
	if (fNAMETable == NULL) {
	LETag nameTag = LE_NAME_TABLE_TAG;
	PortableFontInstance realThis = (PortableFontInstance ) this;

	realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);

	if (realThis->fNAMETable != NULL) {
	realThis->fNameCount = SWAPW(realThis->fNAMETable->count);
	realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
	}
	}

	for(le_int32 i = 0; i < fNameCount; i += 1) {
	const NameRecord *nameRecord = &fNAMETable->nameRecords[i];

	if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
	SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
	char name = ((char ) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset);
	le_uint16 length = SWAPW(nameRecord->length);
	char *result = LE_NEW_ARRAY(char, length + 2);

	LE_ARRAY_COPY(result, name, length);
	result[length] = result[length + 1] = 0;

	return result;
	}
	}

	return NULL;
	}

	const LEUnicode16 *PortableFontInstance::getUnicodeNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
	{
	if (fNAMETable == NULL) {
	LETag nameTag = LE_NAME_TABLE_TAG;
	PortableFontInstance realThis = (PortableFontInstance ) this;

	realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);

	if (realThis->fNAMETable != NULL) {
	realThis->fNameCount = SWAPW(realThis->fNAMETable->count);
	realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
	}
	}

	for(le_int32 i = 0; i < fNameCount; i += 1) {
	const NameRecord *nameRecord = &fNAMETable->nameRecords[i];

	if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
	SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
	LEUnicode16 name = (LEUnicode16 ) (((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset));
	le_uint16 length = SWAPW(nameRecord->length) / 2;
	LEUnicode16 *result = LE_NEW_ARRAY(LEUnicode16, length + 2);

	for (le_int32 c = 0; c < length; c += 1) {
	result[c] = SWAPW(name[c]);
	}

	result[length] = 0;

	return result;
	}
	}

	return NULL;
	}

	void PortableFontInstance::deleteNameString(const char *name) const
	{
	LE_DELETE_ARRAY(name);
	}

	void PortableFontInstance::deleteNameString(const LEUnicode16 *name) const
	{
	LE_DELETE_ARRAY(name);
	}

	void PortableFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
	{
	TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph);

	if (fHMTXTable == NULL) {
	LETag maxpTag = LE_MAXP_TABLE_TAG;
	LETag hmtxTag = LE_HMTX_TABLE_TAG;
	const MAXPTable maxpTable = (MAXPTable ) readFontTable(maxpTag);
	PortableFontInstance realThis = (PortableFontInstance ) this;

	if (maxpTable != NULL) {
	realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs);
	freeFontTable(maxpTable);
	}

	realThis->fHMTXTable = (const HMTXTable *) readFontTable(hmtxTag);
	}

	le_uint16 index = ttGlyph;

	if (ttGlyph >= fNumGlyphs \|\| fHMTXTable == NULL) {
	advance.fX = advance.fY = 0;
	return;
	}

	if (ttGlyph >= fNumLongHorMetrics) {
	index = fNumLongHorMetrics - 1;
	}

	advance.fX = xUnitsToPoints(SWAPW(fHMTXTable->hMetrics[index].advanceWidth));
	advance.fY = 0;
	}

	le_bool PortableFontInstance::getGlyphPoint(LEGlyphID /glyph/, le_int32 /pointNumber/, LEPoint &/point/) const
	{
	return FALSE;
	}

	le_int32 PortableFontInstance::getUnitsPerEM() const
	{
	return fUnitsPerEM;
	}

	le_uint32 PortableFontInstance::getFontChecksum() const
	{
	return fFontChecksum;
	}

	le_uint32 PortableFontInstance::getRawChecksum() const
	{
	// how big is it?
	// fseek(fFile, 0L, SEEK_END);
	// long size = ftell(fFile);
	le_int32 chksum = 0;
	// now, calculate
	fseek(fFile, 0L, SEEK_SET);
	int r;
	int count =0;
	while((r = fgetc(fFile)) != EOF) {
	chksum += r;
	count ++;
	}
	return (le_uint32) chksum; // cast to signed
	}

	le_int32 PortableFontInstance::getAscent() const
	{
	return fAscent;
	}

	le_int32 PortableFontInstance::getDescent() const
	{
	return fDescent;
	}

	le_int32 PortableFontInstance::getLeading() const
	{
	return fLeading;
	}

	// We really want to inherit this method from the superclass, but some compilers
	// issue a warning if we don't implement it...
	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const
	{
	return LEFontInstance::mapCharToGlyph(ch, mapper, filterZeroWidth);
	}

	// We really want to inherit this method from the superclass, but some compilers
	// issue a warning if we don't implement it...
	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const
	{
	return LEFontInstance::mapCharToGlyph(ch, mapper);
	}

	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch) const
	{
	return fCMAPMapper->unicodeToGlyph(ch);
	}

	float PortableFontInstance::getXPixelsPerEm() const
	{
	return fPointSize;
	}

	float PortableFontInstance::getYPixelsPerEm() const
	{
	return fPointSize;
	}

	float PortableFontInstance::getScaleFactorX() const
	{
	return 1.0;
	}

	float PortableFontInstance::getScaleFactorY() const
	{
	return 1.0;
	}