[apple/icu.git] / icuSources / test / letest / PortableFontInstance.cpp

/*
 *******************************************************************************
 *
 *   Copyright (C) 1999-2008, 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>

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

    if (fFile == NULL) {
        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 *) NEW_ARRAY(char, dirSize);

    if (fDirectory == NULL) {
        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;
        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) {
        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) {
        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;

        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 = 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
{
    return FontTableCache::find(tableTag);
}

const void *PortableFontInstance::readFontTable(LETag tableTag) const
{
    le_uint32 len;

    return readTable(tableTag, &len);
}

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 = NEW_ARRAY(char, length + 2);

            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 = 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
{
    DELETE_ARRAY(name);
}

void PortableFontInstance::deleteNameString(const LEUnicode16 *name) const
{
    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_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;
}
Commit	Line	Data
b75a7d8f A	1	/*
	2	*******************************************************************************
	3	*
46f4442e	4	* Copyright (C) 1999-2008, International Business Machines
b75a7d8f A	5	* Corporation and others. All Rights Reserved.
	6	*
	7	*******************************************************************************
	8	* file name: PortableFontInstance.cpp
	9	*
	10	* created on: 11/22/1999
	11	* created by: Eric R. Mader
	12	*/
	13
	14	#include <stdio.h>
	15
	16	#include "layout/LETypes.h"
	17	#include "layout/LEFontInstance.h"
	18	#include "layout/LESwaps.h"
	19
	20	#include "PortableFontInstance.h"
	21
73c04bcf	22	#include "letest.h"
b75a7d8f A	23	#include "sfnt.h"
	24
	25	#include <string.h>
	26
	27	//
	28	// Finds the high bit by binary searching
	29	// through the bits in n.
	30	//
	31	le_int8 PortableFontInstance::highBit(le_int32 value)
	32	{
	33	if (value <= 0) {
	34	return -32;
	35	}
	36
	37	le_uint8 bit = 0;
	38
	39	if (value >= 1 << 16) {
	40	value >>= 16;
	41	bit += 16;
	42	}
	43
	44	if (value >= 1 << 8) {
	45	value >>= 8;
	46	bit += 8;
	47	}
	48
	49	if (value >= 1 << 4) {
	50	value >>= 4;
	51	bit += 4;
	52	}
	53
	54	if (value >= 1 << 2) {
	55	value >>= 2;
	56	bit += 2;
	57	}
	58
	59	if (value >= 1 << 1) {
	60	value >>= 1;
	61	bit += 1;
	62	}
	63
	64	return bit;
	65	}
	66
73c04bcf A	67	PortableFontInstance::PortableFontInstance(const char *fileName, float pointSize, LEErrorCode &status)
	68	: fFile(NULL), fPointSize(pointSize), fUnitsPerEM(0), fFontChecksum(0), fAscent(0), fDescent(0), fLeading(0),
	69	fDirectory(NULL), fNAMETable(NULL), fNameCount(0), fNameStringOffset(0), fCMAPMapper(NULL), fHMTXTable(NULL), fNumGlyphs(0), fNumLongHorMetrics(0)
b75a7d8f A	70	{
	71	if (LE_FAILURE(status)) {
	72	return;
	73	}
	74
	75	// open the font file
	76	fFile = fopen(fileName, "rb");
	77
	78	if (fFile == NULL) {
	79	status = LE_FONT_FILE_NOT_FOUND_ERROR;
	80	return;
	81	}
	82
	83	// read in the directory
	84	SFNTDirectory tempDir;
	85
	86	fread(&tempDir, sizeof tempDir, 1, fFile);
	87
	88	le_int32 dirSize = sizeof tempDir + ((SWAPW(tempDir.numTables) - ANY_NUMBER) * sizeof(DirectoryEntry));
	89	const LETag headTag = LE_HEAD_TABLE_TAG;
	90	const LETag hheaTag = LE_HHEA_TABLE_TAG;
	91	const HEADTable *headTable = NULL;
	92	const HHEATable *hheaTable = NULL;
73c04bcf	93	// const NAMETable *nameTable = NULL;
b75a7d8f A	94	le_uint16 numTables = 0;
b75a7d8f A	95
73c04bcf	96	fDirectory = (const SFNTDirectory *) NEW_ARRAY(char, dirSize);
b75a7d8f A	97
	98	if (fDirectory == NULL) {
	99	status = LE_MEMORY_ALLOCATION_ERROR;
	100	goto error_exit;
	101	}
	102
	103	fseek(fFile, 0L, SEEK_SET);
	104	fread((void *) fDirectory, sizeof(char), dirSize, fFile);
	105
	106	//
	107	// We calculate these numbers 'cause some fonts
	108	// have bogus values for them in the directory header.
	109	//
	110	numTables = SWAPW(fDirectory->numTables);
	111	fDirPower = 1 << highBit(numTables);
	112	fDirExtra = numTables - fDirPower;
	113
	114	// read unitsPerEm from 'head' table
	115	headTable = (const HEADTable *) readFontTable(headTag);
	116
	117	if (headTable == NULL) {
	118	status = LE_MISSING_FONT_TABLE_ERROR;
	119	goto error_exit;
	120	}
	121
73c04bcf A	122	fUnitsPerEM = SWAPW(headTable->unitsPerEm);
73c04bcf A	123	fFontChecksum = SWAPL(headTable->checksumAdjustment);
46f4442e	124	freeFontTable(headTable);
b75a7d8f	125
73c04bcf A	126	//nameTable = (NAMETable *) readFontTable(nameTag);
	127
	128	//if (nameTable == NULL) {
	129	// status = LE_MISSING_FONT_TABLE_ERROR;
	130	// goto error_exit;
	131	//}
	132
	133	//fFontVersionString = findName(nameTable, NAME_VERSION_STRING, PLATFORM_MACINTOSH, MACINTOSH_ROMAN, MACINTOSH_ENGLISH);
	134
	135	//if (fFontVersionString == NULL) {
	136	// status = LE_MISSING_FONT_TABLE_ERROR;
	137	// goto error_exit;
	138	//}
	139
46f4442e	140	//freeFontTable(nameTable);
73c04bcf	141
b75a7d8f A	142	hheaTable = (HHEATable *) readFontTable(hheaTag);
	143
	144	if (hheaTable == NULL) {
	145	status = LE_MISSING_FONT_TABLE_ERROR;
	146	goto error_exit;
	147	}
	148
	149	fAscent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->ascent));
	150	fDescent = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->descent));
	151	fLeading = (le_int32) yUnitsToPoints((float) SWAPW(hheaTable->lineGap));
	152
	153	fNumLongHorMetrics = SWAPW(hheaTable->numOfLongHorMetrics);
	154
46f4442e	155	freeFontTable((void *) hheaTable);
b75a7d8f A	156
	157	fCMAPMapper = findUnicodeMapper();
	158
	159	if (fCMAPMapper == NULL) {
	160	status = LE_MISSING_FONT_TABLE_ERROR;
	161	goto error_exit;
	162	}
	163
	164	return;
	165
	166	error_exit:
	167	fclose(fFile);
	168	fFile = NULL;
	169	return;
	170	}
	171
	172	PortableFontInstance::~PortableFontInstance()
	173	{
	174	if (fFile != NULL) {
	175	fclose(fFile);
	176
46f4442e A	177	freeFontTable(fHMTXTable);
46f4442e A	178	freeFontTable(fNAMETable);
b75a7d8f A	179
	180	delete fCMAPMapper;
	181
73c04bcf	182	DELETE_ARRAY(fDirectory);
b75a7d8f	183	}
73c04bcf	184	}
b75a7d8f	185
b75a7d8f A	186	const DirectoryEntry *PortableFontInstance::findTable(LETag tag) const
	187	{
	188	if (fDirectory != NULL) {
	189	le_uint16 table = 0;
	190	le_uint16 probe = fDirPower;
	191
	192	if (SWAPL(fDirectory->tableDirectory[fDirExtra].tag) <= tag) {
	193	table = fDirExtra;
	194	}
	195
	196	while (probe > (1 << 0)) {
	197	probe >>= 1;
	198
	199	if (SWAPL(fDirectory->tableDirectory[table + probe].tag) <= tag) {
	200	table += probe;
	201	}
	202	}
	203
	204	if (SWAPL(fDirectory->tableDirectory[table].tag) == tag) {
	205	return &fDirectory->tableDirectory[table];
	206	}
	207	}
	208
	209	return NULL;
	210	}
	211
	212	const void PortableFontInstance::readTable(LETag tag, le_uint32 length) const
	213	{
	214	const DirectoryEntry *entry = findTable(tag);
	215
	216	if (entry == NULL) {
	217	*length = 0;
	218	return NULL;
	219	}
	220
	221	*length = SWAPL(entry->length);
	222
73c04bcf	223	void table = NEW_ARRAY(char, length);
b75a7d8f A	224
	225	if (table != NULL) {
	226	fseek(fFile, SWAPL(entry->offset), SEEK_SET);
	227	fread(table, sizeof(char), *length, fFile);
	228	}
	229
	230	return table;
	231	}
	232
	233	const void *PortableFontInstance::getFontTable(LETag tableTag) const
	234	{
	235	return FontTableCache::find(tableTag);
	236	}
	237
	238	const void *PortableFontInstance::readFontTable(LETag tableTag) const
	239	{
	240	le_uint32 len;
	241
	242	return readTable(tableTag, &len);
	243	}
	244
	245	CMAPMapper *PortableFontInstance::findUnicodeMapper()
	246	{
	247	LETag cmapTag = LE_CMAP_TABLE_TAG;
	248	const CMAPTable cmap = (CMAPTable ) readFontTable(cmapTag);
	249
	250	if (cmap == NULL) {
	251	return NULL;
	252	}
	253
	254	return CMAPMapper::createUnicodeMapper(cmap);
	255	}
	256
73c04bcf A	257	const char *PortableFontInstance::getNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
	258	{
	259	if (fNAMETable == NULL) {
	260	LETag nameTag = LE_NAME_TABLE_TAG;
	261	PortableFontInstance realThis = (PortableFontInstance ) this;
	262
	263	realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);
	264
	265	if (realThis->fNAMETable != NULL) {
	266	realThis->fNameCount = SWAPW(realThis->fNAMETable->count);
	267	realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
	268	}
	269	}
	270
	271	for(le_int32 i = 0; i < fNameCount; i += 1) {
	272	const NameRecord *nameRecord = &fNAMETable->nameRecords[i];
	273
46f4442e	274	if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
73c04bcf A	275	SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
	276	char name = ((char ) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset);
	277	le_uint16 length = SWAPW(nameRecord->length);
	278	char *result = NEW_ARRAY(char, length + 2);
	279
	280	ARRAY_COPY(result, name, length);
	281	result[length] = result[length + 1] = 0;
	282
	283	return result;
	284	}
	285	}
	286
	287	return NULL;
	288	}
	289
46f4442e A	290	const LEUnicode16 *PortableFontInstance::getUnicodeNameString(le_uint16 nameID, le_uint16 platformID, le_uint16 encodingID, le_uint16 languageID) const
	291	{
	292	if (fNAMETable == NULL) {
	293	LETag nameTag = LE_NAME_TABLE_TAG;
	294	PortableFontInstance realThis = (PortableFontInstance ) this;
	295
	296	realThis->fNAMETable = (const NAMETable *) readFontTable(nameTag);
	297
	298	if (realThis->fNAMETable != NULL) {
	299	realThis->fNameCount = SWAPW(realThis->fNAMETable->count);
	300	realThis->fNameStringOffset = SWAPW(realThis->fNAMETable->stringOffset);
	301	}
	302	}
	303
	304	for(le_int32 i = 0; i < fNameCount; i += 1) {
	305	const NameRecord *nameRecord = &fNAMETable->nameRecords[i];
	306
	307	if (SWAPW(nameRecord->platformID) == platformID && SWAPW(nameRecord->encodingID) == encodingID &&
	308	SWAPW(nameRecord->languageID) == languageID && SWAPW(nameRecord->nameID) == nameID) {
	309	LEUnicode16 name = (LEUnicode16 ) (((char *) fNAMETable) + fNameStringOffset + SWAPW(nameRecord->offset));
	310	le_uint16 length = SWAPW(nameRecord->length) / 2;
	311	LEUnicode16 *result = NEW_ARRAY(LEUnicode16, length + 2);
	312
	313	for (le_int32 c = 0; c < length; c += 1) {
	314	result[c] = SWAPW(name[c]);
	315	}
	316
	317	result[length] = 0;
	318
	319	return result;
	320	}
	321	}
	322
	323	return NULL;
	324	}
	325
73c04bcf A	326	void PortableFontInstance::deleteNameString(const char *name) const
	327	{
	328	DELETE_ARRAY(name);
	329	}
b75a7d8f	330
46f4442e A	331	void PortableFontInstance::deleteNameString(const LEUnicode16 *name) const
	332	{
	333	DELETE_ARRAY(name);
	334	}
	335
b75a7d8f A	336	void PortableFontInstance::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const
	337	{
	338	TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph);
	339
	340	if (fHMTXTable == NULL) {
	341	LETag maxpTag = LE_MAXP_TABLE_TAG;
	342	LETag hmtxTag = LE_HMTX_TABLE_TAG;
	343	const MAXPTable maxpTable = (MAXPTable ) readFontTable(maxpTag);
	344	PortableFontInstance realThis = (PortableFontInstance ) this;
	345
	346	if (maxpTable != NULL) {
	347	realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs);
46f4442e	348	freeFontTable(maxpTable);
b75a7d8f A	349	}
	350
	351	realThis->fHMTXTable = (const HMTXTable *) readFontTable(hmtxTag);
	352	}
	353
	354	le_uint16 index = ttGlyph;
	355
	356	if (ttGlyph >= fNumGlyphs \|\| fHMTXTable == NULL) {
	357	advance.fX = advance.fY = 0;
	358	return;
	359	}
	360
	361	if (ttGlyph >= fNumLongHorMetrics) {
	362	index = fNumLongHorMetrics - 1;
	363	}
	364
	365	advance.fX = xUnitsToPoints(SWAPW(fHMTXTable->hMetrics[index].advanceWidth));
	366	advance.fY = 0;
	367	}
	368
73c04bcf	369	le_bool PortableFontInstance::getGlyphPoint(LEGlyphID /glyph/, le_int32 /pointNumber/, LEPoint &/point/) const
b75a7d8f	370	{
374ca955	371	return FALSE;
b75a7d8f A	372	}
b75a7d8f A	373
73c04bcf A	374	le_int32 PortableFontInstance::getUnitsPerEM() const
	375	{
	376	return fUnitsPerEM;
	377	}
	378
	379	le_uint32 PortableFontInstance::getFontChecksum() const
	380	{
	381	return fFontChecksum;
	382	}
	383
	384	le_int32 PortableFontInstance::getAscent() const
	385	{
	386	return fAscent;
	387	}
	388
	389	le_int32 PortableFontInstance::getDescent() const
	390	{
	391	return fDescent;
	392	}
	393
	394	le_int32 PortableFontInstance::getLeading() const
	395	{
	396	return fLeading;
	397	}
	398
	399	// We really want to inherit this method from the superclass, but some compilers
	400	// issue a warning if we don't implement it...
	401	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper, le_bool filterZeroWidth) const
	402	{
	403	return LEFontInstance::mapCharToGlyph(ch, mapper, filterZeroWidth);
	404	}
	405
	406	// We really want to inherit this method from the superclass, but some compilers
	407	// issue a warning if we don't implement it...
	408	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch, const LECharMapper *mapper) const
	409	{
	410	return LEFontInstance::mapCharToGlyph(ch, mapper);
	411	}
	412
	413	LEGlyphID PortableFontInstance::mapCharToGlyph(LEUnicode32 ch) const
	414	{
	415	return fCMAPMapper->unicodeToGlyph(ch);
	416	}
	417
	418	float PortableFontInstance::getXPixelsPerEm() const
	419	{
	420	return fPointSize;
	421	}
	422
	423	float PortableFontInstance::getYPixelsPerEm() const
	424	{
	425	return fPointSize;
	426	}
	427
	428	float PortableFontInstance::getScaleFactorX() const
	429	{
	430	return 1.0;
	431	}
	432
	433	float PortableFontInstance::getScaleFactorY() const
	434	{
	435	return 1.0;
	436	}