scuffed-code/icu4c/source/test/letest/PortableFontInstance.cpp
Eric Mader 61b54a383a ICU-4288 fix lots of build warnings
X-SVN-Rev: 17264
2005-02-28 23:18:05 +00:00

337 lines
8.5 KiB
C++

/*
*******************************************************************************
*
* Copyright (C) 1999-2005, 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 "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 *) LE_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);
deleteTable(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;
//}
//deleteTable(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);
deleteTable((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);
deleteTable(fHMTXTable);
deleteTable(fNAMETable);
delete fCMAPMapper;
LE_DELETE_ARRAY(fDirectory);
}
}
void PortableFontInstance::deleteTable(const void *table) const
{
LE_DELETE_ARRAY(table);
}
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
{
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 = LE_NEW_ARRAY(char, length + 2);
LE_ARRAY_COPY(result, name, length);
result[length] = result[length + 1] = 0;
return result;
}
}
return NULL;
}
void PortableFontInstance::deleteNameString(const char *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);
deleteTable(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;
}