339 lines
10 KiB
C++
339 lines
10 KiB
C++
/*
|
|
* HangulLayoutEngine.cpp: OpenType processing for Han fonts.
|
|
*
|
|
* (C) Copyright IBM Corp. 1998-2013 - All Rights Reserved.
|
|
*/
|
|
|
|
#include "LETypes.h"
|
|
#include "LEScripts.h"
|
|
#include "LELanguages.h"
|
|
|
|
#include "LayoutEngine.h"
|
|
#include "OpenTypeLayoutEngine.h"
|
|
#include "HangulLayoutEngine.h"
|
|
#include "ScriptAndLanguageTags.h"
|
|
#include "LEGlyphStorage.h"
|
|
#include "OpenTypeTables.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HangulOpenTypeLayoutEngine)
|
|
|
|
|
|
#define FEATURE_MAP(name) {name ## FeatureTag, name ## FeatureMask}
|
|
|
|
#define LJMO_FIRST 0x1100
|
|
#define LJMO_LAST 0x1159
|
|
#define LJMO_FILL 0x115F
|
|
#define LJMO_COUNT 19
|
|
|
|
#define VJMO_FIRST 0x1161
|
|
#define VJMO_LAST 0x11A2
|
|
#define VJMO_FILL 0x1160
|
|
#define VJMO_COUNT 21
|
|
|
|
#define TJMO_FIRST 0x11A7
|
|
#define TJMO_LAST 0x11F9
|
|
#define TJMO_COUNT 28
|
|
|
|
#define HSYL_FIRST 0xAC00
|
|
#define HSYL_COUNT 11172
|
|
#define HSYL_LVCNT (VJMO_COUNT * TJMO_COUNT)
|
|
|
|
// Character classes
|
|
enum
|
|
{
|
|
CC_L = 0,
|
|
CC_V,
|
|
CC_T,
|
|
CC_LV,
|
|
CC_LVT,
|
|
CC_X,
|
|
CC_COUNT
|
|
};
|
|
|
|
// Action flags
|
|
#define AF_L 1
|
|
#define AF_V 2
|
|
#define AF_T 4
|
|
|
|
// Actions
|
|
#define a_N 0
|
|
#define a_L (AF_L)
|
|
#define a_V (AF_V)
|
|
#define a_T (AF_T)
|
|
#define a_VT (AF_V | AF_T)
|
|
#define a_LV (AF_L | AF_V)
|
|
#define a_LVT (AF_L | AF_V | AF_T)
|
|
|
|
typedef struct
|
|
{
|
|
int32_t newState;
|
|
int32_t actionFlags;
|
|
} StateTransition;
|
|
|
|
static const StateTransition stateTable[][CC_COUNT] =
|
|
{
|
|
// L V T LV LVT X
|
|
{ {1, a_L}, {2, a_LV}, {3, a_LVT}, {2, a_LV}, {3, a_LVT}, {4, a_T}}, // 0 - start
|
|
{ {1, a_L}, {2, a_V}, {3, a_VT}, {2, a_LV}, {3, a_LVT}, {-1, a_V}}, // 1 - L+
|
|
{{-1, a_N}, {2, a_V}, {3, a_T}, {-1, a_N}, {-1, a_N}, {-1, a_N}}, // 2 - L+V+
|
|
{{-1, a_N}, {-1, a_N}, {3, a_T}, {-1, a_N}, {-1, a_N}, {-1, a_N}}, // 3 - L+V+T*
|
|
{{-1, a_N}, {-1, a_N}, {-1, a_N}, {-1, a_N}, {-1, a_N}, {4, a_T}} // 4 - X+
|
|
};
|
|
|
|
|
|
#define ccmpFeatureTag LE_CCMP_FEATURE_TAG
|
|
#define ljmoFeatureTag LE_LJMO_FEATURE_TAG
|
|
#define vjmoFeatureTag LE_VJMO_FEATURE_TAG
|
|
#define tjmoFeatureTag LE_TJMO_FEATURE_TAG
|
|
|
|
#define ccmpFeatureMask 0x80000000UL
|
|
#define ljmoFeatureMask 0x40000000UL
|
|
#define vjmoFeatureMask 0x20000000UL
|
|
#define tjmoFeatureMask 0x10000000UL
|
|
|
|
static const FeatureMap featureMap[] =
|
|
{
|
|
{ccmpFeatureTag, ccmpFeatureMask},
|
|
{ljmoFeatureTag, ljmoFeatureMask},
|
|
{vjmoFeatureTag, vjmoFeatureMask},
|
|
{tjmoFeatureTag, tjmoFeatureMask}
|
|
};
|
|
|
|
static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
|
|
|
|
#define nullFeatures 0
|
|
#define ljmoFeatures (ccmpFeatureMask | ljmoFeatureMask)
|
|
#define vjmoFeatures (ccmpFeatureMask | vjmoFeatureMask | ljmoFeatureMask | tjmoFeatureMask)
|
|
#define tjmoFeatures (ccmpFeatureMask | tjmoFeatureMask | ljmoFeatureMask | vjmoFeatureMask)
|
|
|
|
static le_int32 compose(LEUnicode lead, LEUnicode vowel, LEUnicode trail, LEUnicode &syllable)
|
|
{
|
|
le_int32 lIndex = lead - LJMO_FIRST;
|
|
le_int32 vIndex = vowel - VJMO_FIRST;
|
|
le_int32 tIndex = trail - TJMO_FIRST;
|
|
le_int32 result = 3;
|
|
|
|
if ((lIndex < 0 || lIndex >= LJMO_COUNT ) || (vIndex < 0 || vIndex >= VJMO_COUNT)) {
|
|
return 0;
|
|
}
|
|
|
|
if (tIndex <= 0 || tIndex >= TJMO_COUNT) {
|
|
tIndex = 0;
|
|
result = 2;
|
|
}
|
|
|
|
syllable = (LEUnicode) ((lIndex * VJMO_COUNT + vIndex) * TJMO_COUNT + tIndex + HSYL_FIRST);
|
|
|
|
return result;
|
|
}
|
|
|
|
static le_int32 decompose(LEUnicode syllable, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail)
|
|
{
|
|
le_int32 sIndex = syllable - HSYL_FIRST;
|
|
|
|
if (sIndex < 0 || sIndex >= HSYL_COUNT) {
|
|
return 0;
|
|
}
|
|
|
|
lead = LJMO_FIRST + (sIndex / HSYL_LVCNT);
|
|
vowel = VJMO_FIRST + (sIndex % HSYL_LVCNT) / TJMO_COUNT;
|
|
trail = TJMO_FIRST + (sIndex % TJMO_COUNT);
|
|
|
|
if (trail == TJMO_FIRST) {
|
|
return 2;
|
|
}
|
|
|
|
return 3;
|
|
}
|
|
|
|
static le_int32 getCharClass(LEUnicode ch, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail)
|
|
{
|
|
lead = LJMO_FILL;
|
|
vowel = VJMO_FILL;
|
|
trail = TJMO_FIRST;
|
|
|
|
if (ch >= LJMO_FIRST && ch <= LJMO_LAST) {
|
|
lead = ch;
|
|
return CC_L;
|
|
}
|
|
|
|
if (ch >= VJMO_FIRST && ch <= VJMO_LAST) {
|
|
vowel = ch;
|
|
return CC_V;
|
|
}
|
|
|
|
if (ch > TJMO_FIRST && ch <= TJMO_LAST) {
|
|
trail = ch;
|
|
return CC_T;
|
|
}
|
|
|
|
le_int32 c = decompose(ch, lead, vowel, trail);
|
|
|
|
if (c == 2) {
|
|
return CC_LV;
|
|
}
|
|
|
|
if (c == 3) {
|
|
return CC_LVT;
|
|
}
|
|
|
|
trail = ch;
|
|
return CC_X;
|
|
}
|
|
|
|
HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/,
|
|
le_int32 typoFlags, const LEReferenceTo<GlyphSubstitutionTableHeader> &gsubTable, LEErrorCode &success)
|
|
: OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, gsubTable, success)
|
|
{
|
|
fFeatureMap = featureMap;
|
|
fFeatureMapCount = featureMapCount;
|
|
fFeatureOrder = TRUE;
|
|
}
|
|
|
|
HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/,
|
|
le_int32 typoFlags, LEErrorCode &success)
|
|
: OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, success)
|
|
{
|
|
fFeatureMap = featureMap;
|
|
fFeatureMapCount = featureMapCount;
|
|
fFeatureOrder = TRUE;
|
|
}
|
|
|
|
HangulOpenTypeLayoutEngine::~HangulOpenTypeLayoutEngine()
|
|
{
|
|
// nothing to do
|
|
}
|
|
|
|
le_int32 HangulOpenTypeLayoutEngine::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 (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
|
|
success = LE_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
le_int32 worstCase = count * 3;
|
|
|
|
outChars = LE_NEW_ARRAY(LEUnicode, worstCase);
|
|
|
|
if (outChars == NULL) {
|
|
success = LE_MEMORY_ALLOCATION_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
glyphStorage.allocateGlyphArray(worstCase, rightToLeft, success);
|
|
glyphStorage.allocateAuxData(success);
|
|
|
|
if (LE_FAILURE(success)) {
|
|
LE_DELETE_ARRAY(outChars);
|
|
return 0;
|
|
}
|
|
|
|
le_int32 outCharCount = 0;
|
|
le_int32 limit = offset + count;
|
|
le_int32 i = offset;
|
|
|
|
while (i < limit) {
|
|
le_int32 state = 0;
|
|
le_int32 inStart = i;
|
|
le_int32 outStart = outCharCount;
|
|
|
|
while( i < limit) {
|
|
LEUnicode lead = 0;
|
|
LEUnicode vowel = 0;
|
|
LEUnicode trail = 0;
|
|
int32_t chClass = getCharClass(chars[i], lead, vowel, trail);
|
|
const StateTransition transition = stateTable[state][chClass];
|
|
|
|
if (chClass == CC_X) {
|
|
/* Any character of type X will be stored as a trail jamo */
|
|
if ((transition.actionFlags & AF_T) != 0) {
|
|
outChars[outCharCount] = trail;
|
|
glyphStorage.setCharIndex(outCharCount, i-offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
|
|
}
|
|
} else {
|
|
/* Any Hangul will be fully decomposed. Output the decomposed characters. */
|
|
if ((transition.actionFlags & AF_L) != 0) {
|
|
outChars[outCharCount] = lead;
|
|
glyphStorage.setCharIndex(outCharCount, i-offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, ljmoFeatures, success);
|
|
}
|
|
|
|
if ((transition.actionFlags & AF_V) != 0) {
|
|
outChars[outCharCount] = vowel;
|
|
glyphStorage.setCharIndex(outCharCount, i-offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, vjmoFeatures, success);
|
|
}
|
|
|
|
if ((transition.actionFlags & AF_T) != 0) {
|
|
outChars[outCharCount] = trail;
|
|
glyphStorage.setCharIndex(outCharCount, i-offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, tjmoFeatures, success);
|
|
}
|
|
}
|
|
|
|
state = transition.newState;
|
|
|
|
/* Negative next state means stop. */
|
|
if (state < 0) {
|
|
break;
|
|
}
|
|
|
|
i += 1;
|
|
}
|
|
|
|
le_int32 inLength = i - inStart;
|
|
le_int32 outLength = outCharCount - outStart;
|
|
|
|
/*
|
|
* See if the syllable can be composed into a single character. There are 5
|
|
* possible cases:
|
|
*
|
|
* Input Decomposed to Compose to
|
|
* LV L, V LV
|
|
* LVT L, V, T LVT
|
|
* L, V L, V LV, DEL
|
|
* LV, T L, V, T LVT, DEL
|
|
* L, V, T L, V, T LVT, DEL, DEL
|
|
*/
|
|
if ((inLength >= 1 && inLength <= 3) && (outLength == 2 || outLength == 3)) {
|
|
LEUnicode syllable = 0x0000;
|
|
LEUnicode lead = outChars[outStart];
|
|
LEUnicode vowel = outChars[outStart + 1];
|
|
LEUnicode trail = outLength == 3? outChars[outStart + 2] : TJMO_FIRST;
|
|
|
|
/*
|
|
* If the composition consumes the whole decomposed syllable,
|
|
* we can use it.
|
|
*/
|
|
if (compose(lead, vowel, trail, syllable) == outLength) {
|
|
outCharCount = outStart;
|
|
outChars[outCharCount] = syllable;
|
|
glyphStorage.setCharIndex(outCharCount, inStart-offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
|
|
|
|
/*
|
|
* Replace the rest of the input characters with DEL.
|
|
*/
|
|
for(le_int32 d = inStart + 1; d < i; d += 1) {
|
|
outChars[outCharCount] = 0xFFFF;
|
|
glyphStorage.setCharIndex(outCharCount, d - offset, success);
|
|
glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
glyphStorage.adoptGlyphCount(outCharCount);
|
|
return outCharCount;
|
|
}
|
|
|
|
U_NAMESPACE_END
|