[apple/icu.git] / icuSources / test / perf / leperf / PortableFontInstance.cpp

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