diff options
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/layout/LayoutEngine.cpp')
| -rw-r--r-- | Build/source/libs/icu/icu-xetex/layout/LayoutEngine.cpp | 622 |
1 files changed, 622 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/layout/LayoutEngine.cpp b/Build/source/libs/icu/icu-xetex/layout/LayoutEngine.cpp new file mode 100644 index 00000000000..b56854fa934 --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/layout/LayoutEngine.cpp @@ -0,0 +1,622 @@ + +/* + * + * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved + * + */ + +#include "LETypes.h" +#include "LEScripts.h" +#include "LELanguages.h" + +#include "LayoutEngine.h" +#include "ArabicLayoutEngine.h" +#include "CanonShaping.h" +#include "HanLayoutEngine.h" +#include "HangulLayoutEngine.h" +#include "IndicLayoutEngine.h" +#include "KhmerLayoutEngine.h" +#include "ThaiLayoutEngine.h" +#include "TibetanLayoutEngine.h" +#include "GXLayoutEngine.h" +#include "ScriptAndLanguageTags.h" +#include "CharSubstitutionFilter.h" + +#include "LEGlyphStorage.h" + +#include "OpenTypeUtilities.h" +#include "GlyphSubstitutionTables.h" +#include "GlyphDefinitionTables.h" +#include "MorphTables.h" + +#include "DefaultCharMapper.h" + +#include "KernTable.h" + +U_NAMESPACE_BEGIN + +/* Leave this copyright notice here! It needs to go somewhere in this library. */ +static const char copyright[] = U_COPYRIGHT_STRING; + +const LEUnicode32 DefaultCharMapper::controlChars[] = { + 0x0009, 0x000A, 0x000D, + /*0x200C, 0x200D,*/ 0x200E, 0x200F, + 0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E, + 0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F +}; + +const le_int32 DefaultCharMapper::controlCharsCount = LE_ARRAY_SIZE(controlChars); + +LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const +{ + if (fFilterControls) { + le_int32 index = OpenTypeUtilities::search((le_uint32)ch, (le_uint32 *)controlChars, controlCharsCount); + + if (controlChars[index] == ch) { + return 0xFFFF; + } + } + + if (fMirror) { + le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)DefaultCharMapper::mirroredChars, DefaultCharMapper::mirroredCharsCount); + + if (mirroredChars[index] == ch) { + return DefaultCharMapper::srahCderorrim[index]; + } + } + + return ch; +} + +// This is here to get it out of LEGlyphFilter.h. +// No particular reason to put it here, other than +// this is a good central location... +LEGlyphFilter::~LEGlyphFilter() +{ + // nothing to do +} + +CharSubstitutionFilter::CharSubstitutionFilter(const LEFontInstance *fontInstance) + : fFontInstance(fontInstance) +{ + // nothing to do +} + +CharSubstitutionFilter::~CharSubstitutionFilter() +{ + // nothing to do +} + +class CanonMarkFilter : public UMemory, public LEGlyphFilter +{ +private: + const GlyphClassDefinitionTable *classDefTable; + + CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class + CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class + +public: + CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable); + virtual ~CanonMarkFilter(); + + virtual le_bool accept(LEGlyphID glyph) const; +}; + +CanonMarkFilter::CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable) +{ + classDefTable = gdefTable->getMarkAttachClassDefinitionTable(); +} + +CanonMarkFilter::~CanonMarkFilter() +{ + // nothing to do? +} + +le_bool CanonMarkFilter::accept(LEGlyphID glyph) const +{ + le_int32 glyphClass = classDefTable->getGlyphClass(glyph); + + return glyphClass != 0; +} + +UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine) + +#define ccmpFeatureTag LE_CCMP_FEATURE_TAG + +#define ccmpFeatureMask 0x80000000UL + +#define canonFeatures (ccmpFeatureMask) + +static const FeatureMap canonFeatureMap[] = +{ + {ccmpFeatureTag, ccmpFeatureMask} +}; + +static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap); + +LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags) + : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode), + fTypoFlags(typoFlags), fFilterZeroWidth(TRUE) +{ + fGlyphStorage = new LEGlyphStorage(); +} + +le_int32 LayoutEngine::getGlyphCount() const +{ + return fGlyphStorage->getGlyphCount(); +} + +void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const +{ + fGlyphStorage->getCharIndices(charIndices, indexBase, success); +} + +void LayoutEngine::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const +{ + fGlyphStorage->getCharIndices(charIndices, success); +} + +// Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits +void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const +{ + fGlyphStorage->getGlyphs(glyphs, extraBits, success); +} + +void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const +{ + fGlyphStorage->getGlyphs(glyphs, success); +} + + +void LayoutEngine::getGlyphPositions(float positions[], LEErrorCode &success) const +{ + fGlyphStorage->getGlyphPositions(positions, success); +} + +void LayoutEngine::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const +{ + fGlyphStorage->getGlyphPosition(glyphIndex, x, y, success); +} + +le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEUnicode *&outChars, LEGlyphStorage &/*glyphStorage*/, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return 0; + } + + if (offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + + const GlyphSubstitutionTableHeader *canonGSUBTable = (GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable; + LETag scriptTag = OpenTypeLayoutEngine::getScriptTag(fScriptCode); + LETag langSysTag = OpenTypeLayoutEngine::getLangSysTag(fLanguageCode); + le_int32 i, dir = 1, out = 0, outCharCount = count; + + if (canonGSUBTable->coversScript(scriptTag)) { + CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance); + const LEUnicode *inChars = &chars[offset]; + LEUnicode *reordered = NULL; + LEGlyphStorage fakeGlyphStorage; + + fakeGlyphStorage.allocateGlyphArray(count, rightToLeft, success); + + if (LE_FAILURE(success)) { + return 0; + } + + // This is the cheapest way to get mark reordering only for Hebrew. + // We could just do the mark reordering for all scripts, but most + // of them probably don't need it... + if (fScriptCode == hebrScriptCode) { + reordered = LE_NEW_ARRAY(LEUnicode, count); + + if (reordered == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + return 0; + } + + CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, fakeGlyphStorage); + inChars = reordered; + } + + fakeGlyphStorage.allocateAuxData(success); + + if (LE_FAILURE(success)) { + return 0; + } + + if (rightToLeft) { + out = count - 1; + dir = -1; + } + + for (i = 0; i < count; i += 1, out += dir) { + fakeGlyphStorage[out] = (LEGlyphID) inChars[i]; + fakeGlyphStorage.setAuxData(out, canonFeatures, NULL, success); + } + + if (reordered != NULL) { + LE_DELETE_ARRAY(reordered); + } + + outCharCount = canonGSUBTable->process(fakeGlyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE); + + out = (rightToLeft? outCharCount - 1 : 0); + + outChars = LE_NEW_ARRAY(LEUnicode, outCharCount); + for (i = 0; i < outCharCount; i += 1, out += dir) { + outChars[out] = (LEUnicode) LE_GET_GLYPH(fakeGlyphStorage[i]); + } + + delete substitutionFilter; + } + + return outCharCount; +} + +le_int32 LayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + LEGlyphStorage &glyphStorage, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return 0; + } + + if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + + LEUnicode *outChars = NULL; + le_int32 outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success); + + if (outChars != NULL) { + mapCharsToGlyphs(outChars, 0, outCharCount, rightToLeft, rightToLeft, glyphStorage, success); + LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work... + } else { + mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success); + } + + return glyphStorage.getGlyphCount(); +} + +// Input: glyphs +// Output: positions +void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return; + } + + glyphStorage.allocatePositions(success); + + if (LE_FAILURE(success)) { + return; + } + + le_int32 i, glyphCount = glyphStorage.getGlyphCount(); + + for (i = 0; i < glyphCount; i += 1) { + LEPoint advance; + + glyphStorage.setPosition(i, x, y, success); + + fFontInstance->getGlyphAdvance(glyphStorage[i], advance); + x += advance.fX; + y += advance.fY; + } + + glyphStorage.setPosition(glyphCount, x, y, success); +} + +void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, + LEGlyphStorage &glyphStorage, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return; + } + + if (chars == NULL || offset < 0 || count < 0) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return; + } + + GlyphDefinitionTableHeader *gdefTable = (GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable; + CanonMarkFilter filter(gdefTable); + + adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success); + + if (fTypoFlags & 0x1) { /* kerning enabled */ + static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG; + const void* kernTableData = getFontTable(kernTableTag); + if (kernTableData != NULL) { + KernTable kt(fFontInstance, kernTableData); + kt.process(glyphStorage); + } + else { /* no 'kern' table, but the font might know kern pairs from an AFM file, for instance */ + float xAdjust = 0.0, yAdjust = 0.0; + LEGlyphID leftGlyph = glyphStorage.getGlyphID(0, success); + for (le_int32 i = 1; i < glyphStorage.getGlyphCount(); ++i) { + LEGlyphID rightGlyph = glyphStorage.getGlyphID(i, success); + LEPoint kern; + fFontInstance->getKernPair(leftGlyph, rightGlyph, kern); + xAdjust += fFontInstance->xUnitsToPoints(kern.fX); + yAdjust += fFontInstance->yUnitsToPoints(kern.fY); + glyphStorage.adjustPosition(i, xAdjust, yAdjust, success); + leftGlyph = rightGlyph; + } + glyphStorage.adjustPosition(glyphStorage.getGlyphCount(), xAdjust, yAdjust, success); + } + } + + // default is no adjustments + return; +} + +void LayoutEngine::adjustMarkGlyphs(LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success) +{ + float xAdjust = 0; + le_int32 p, glyphCount = glyphStorage.getGlyphCount(); + + if (LE_FAILURE(success)) { + return; + } + + if (markFilter == NULL) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return; + } + + float ignore, prev; + + glyphStorage.getGlyphPosition(0, prev, ignore, success); + + for (p = 0; p < glyphCount; p += 1) { + float next, xAdvance; + + glyphStorage.getGlyphPosition(p + 1, next, ignore, success); + + xAdvance = next - prev; + glyphStorage.adjustPosition(p, xAdjust, 0, success); + + if (markFilter->accept(glyphStorage[p])) { + xAdjust -= xAdvance; + } + + prev = next; + } + + glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success); +} + +void LayoutEngine::adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success) +{ + float xAdjust = 0; + le_int32 c = 0, direction = 1, p; + le_int32 glyphCount = glyphStorage.getGlyphCount(); + + if (LE_FAILURE(success)) { + return; + } + + if (markFilter == NULL) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return; + } + + if (reverse) { + c = glyphCount - 1; + direction = -1; + } + + float ignore, prev; + + glyphStorage.getGlyphPosition(0, prev, ignore, success); + + for (p = 0; p < charCount; p += 1, c += direction) { + float next, xAdvance; + + glyphStorage.getGlyphPosition(p + 1, next, ignore, success); + + xAdvance = next - prev; + glyphStorage.adjustPosition(p, xAdjust, 0, success); + + if (markFilter->accept(chars[c])) { + xAdjust -= xAdvance; + } + + prev = next; + } + + glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success); +} + +const void *LayoutEngine::getFontTable(LETag tableTag) const +{ + return fFontInstance->getFontTable(tableTag); +} + +void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror, + LEGlyphStorage &glyphStorage, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return; + } + + glyphStorage.allocateGlyphArray(count, reverse, success); + + DefaultCharMapper charMapper(TRUE, mirror); + + fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage); +} + +// Input: characters, font? +// Output: glyphs, positions, char indices +// Returns: number of glyphs +le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, + float x, float y, LEErrorCode &success) +{ + if (LE_FAILURE(success)) { + return 0; + } + + if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) { + success = LE_ILLEGAL_ARGUMENT_ERROR; + return 0; + } + + le_int32 glyphCount; + + if (fGlyphStorage->getGlyphCount() > 0) { + fGlyphStorage->reset(); + } + + glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success); + positionGlyphs(*fGlyphStorage, x, y, success); + adjustGlyphPositions(chars, offset, count, rightToLeft, *fGlyphStorage, success); + + return glyphCount; +} + +void LayoutEngine::reset() +{ + fGlyphStorage->reset(); +} + +LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success) +{ + // 3 -> kerning and ligatures + return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, languageCode, 3, success); +} + +LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success) +{ + static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG; + static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG; + + if (LE_FAILURE(success)) { + return NULL; + } + + const GlyphSubstitutionTableHeader *gsubTable = (const GlyphSubstitutionTableHeader *) fontInstance->getFontTable(gsubTableTag); + LayoutEngine *result = NULL; + LETag scriptTag = 0x00000000; + LETag languageTag = 0x00000000; + + if (gsubTable != NULL && gsubTable->coversScript(scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode))) { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: + case gujrScriptCode: + case kndaScriptCode: + case mlymScriptCode: + case oryaScriptCode: + case guruScriptCode: + case tamlScriptCode: + case teluScriptCode: + case sinhScriptCode: + result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case arabScriptCode: + case syrcScriptCode: + case mongScriptCode: + result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case hangScriptCode: + result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case haniScriptCode: + languageTag = OpenTypeLayoutEngine::getLangSysTag(languageCode); + + switch (languageCode) { + case korLanguageCode: + case janLanguageCode: + case zhtLanguageCode: + case zhsLanguageCode: + if (gsubTable->coversScriptAndLanguage(scriptTag, languageTag, TRUE)) { + result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + + // note: falling through to default case. + default: + result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + + break; + + case tibtScriptCode: + result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case khmrScriptCode: + result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + default: + result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + } + } else { + const MorphTableHeader *morphTable = (MorphTableHeader *) fontInstance->getFontTable(mortTableTag); + + if (morphTable != NULL) { + result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, morphTable); + } else { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: + case gujrScriptCode: + case kndaScriptCode: + case mlymScriptCode: + case oryaScriptCode: + case guruScriptCode: + case tamlScriptCode: + case teluScriptCode: + case sinhScriptCode: + { + result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + } + + case arabScriptCode: + //case hebrScriptCode: + result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + //case hebrScriptCode: + // return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + + case thaiScriptCode: + result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + case hangScriptCode: + result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + default: + result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + } + } + } + + if (result == NULL) { + success = LE_MEMORY_ALLOCATION_ERROR; + } + + return result; +} + +LayoutEngine::~LayoutEngine() { + delete fGlyphStorage; +} + +U_NAMESPACE_END |