Home | History | Annotate | Download | only in layout
      1 /*
      2  * HangulLayoutEngine.cpp: OpenType processing for Han fonts.
      3  *
      4  * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved.
      5  */
      6 
      7 #include "LETypes.h"
      8 #include "LEScripts.h"
      9 #include "LELanguages.h"
     10 
     11 #include "LayoutEngine.h"
     12 #include "OpenTypeLayoutEngine.h"
     13 #include "HangulLayoutEngine.h"
     14 #include "ScriptAndLanguageTags.h"
     15 #include "LEGlyphStorage.h"
     16 #include "OpenTypeTables.h"
     17 
     18 U_NAMESPACE_BEGIN
     19 
     20 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HangulOpenTypeLayoutEngine)
     21 
     22 
     23 #define FEATURE_MAP(name) {name ## FeatureTag, name ## FeatureMask}
     24 
     25 #define LJMO_FIRST 0x1100
     26 #define LJMO_LAST  0x1159
     27 #define LJMO_FILL  0x115F
     28 #define LJMO_COUNT 19
     29 
     30 #define VJMO_FIRST 0x1161
     31 #define VJMO_LAST  0x11A2
     32 #define VJMO_FILL  0x1160
     33 #define VJMO_COUNT 21
     34 
     35 #define TJMO_FIRST 0x11A7
     36 #define TJMO_LAST  0x11F9
     37 #define TJMO_COUNT 28
     38 
     39 #define HSYL_FIRST 0xAC00
     40 #define HSYL_COUNT 11172
     41 #define HSYL_LVCNT (VJMO_COUNT * TJMO_COUNT)
     42 
     43 // Character classes
     44 enum
     45 {
     46     CC_L = 0,
     47     CC_V,
     48     CC_T,
     49     CC_LV,
     50     CC_LVT,
     51     CC_X,
     52     CC_COUNT
     53 };
     54 
     55 // Action flags
     56 #define AF_L 1
     57 #define AF_V 2
     58 #define AF_T 4
     59 
     60 // Actions
     61 #define a_N   0
     62 #define a_L   (AF_L)
     63 #define a_V   (AF_V)
     64 #define a_T   (AF_T)
     65 #define a_VT  (AF_V | AF_T)
     66 #define a_LV  (AF_L | AF_V)
     67 #define a_LVT (AF_L | AF_V | AF_T)
     68 
     69 typedef struct
     70 {
     71     int32_t newState;
     72     int32_t actionFlags;
     73 } StateTransition;
     74 
     75 static const StateTransition stateTable[][CC_COUNT] =
     76 {
     77 //       L          V          T          LV         LVT           X
     78     { {1, a_L},  {2, a_LV}, {3, a_LVT}, {2, a_LV}, {3, a_LVT},  {4, a_T}}, // 0 - start
     79     { {1, a_L},  {2, a_V},  {3, a_VT},  {2, a_LV}, {3, a_LVT}, {-1, a_V}}, // 1 - L+
     80     {{-1, a_N},  {2, a_V},  {3, a_T},  {-1, a_N}, {-1, a_N},   {-1, a_N}}, // 2 - L+V+
     81     {{-1, a_N}, {-1, a_N},  {3, a_T},  {-1, a_N}, {-1, a_N},   {-1, a_N}}, // 3 - L+V+T*
     82     {{-1, a_N}, {-1, a_N}, {-1, a_N},  {-1, a_N}, {-1, a_N},    {4, a_T}}  // 4 - X+
     83 };
     84 
     85 
     86 #define ccmpFeatureTag LE_CCMP_FEATURE_TAG
     87 #define ljmoFeatureTag LE_LJMO_FEATURE_TAG
     88 #define vjmoFeatureTag LE_VJMO_FEATURE_TAG
     89 #define tjmoFeatureTag LE_TJMO_FEATURE_TAG
     90 
     91 #define ccmpFeatureMask 0x80000000UL
     92 #define ljmoFeatureMask 0x40000000UL
     93 #define vjmoFeatureMask 0x20000000UL
     94 #define tjmoFeatureMask 0x10000000UL
     95 
     96 static const FeatureMap featureMap[] =
     97 {
     98     {ccmpFeatureTag, ccmpFeatureMask},
     99     {ljmoFeatureTag, ljmoFeatureMask},
    100     {vjmoFeatureTag, vjmoFeatureMask},
    101     {tjmoFeatureTag, tjmoFeatureMask}
    102 };
    103 
    104 static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
    105 
    106 #define nullFeatures 0
    107 #define ljmoFeatures (ccmpFeatureMask | ljmoFeatureMask)
    108 #define vjmoFeatures (ccmpFeatureMask | vjmoFeatureMask | ljmoFeatureMask | tjmoFeatureMask)
    109 #define tjmoFeatures (ccmpFeatureMask | tjmoFeatureMask | ljmoFeatureMask | vjmoFeatureMask)
    110 
    111 static le_int32 compose(LEUnicode lead, LEUnicode vowel, LEUnicode trail, LEUnicode &syllable)
    112 {
    113     le_int32 lIndex = lead  - LJMO_FIRST;
    114     le_int32 vIndex = vowel - VJMO_FIRST;
    115     le_int32 tIndex = trail - TJMO_FIRST;
    116     le_int32 result = 3;
    117 
    118     if ((lIndex < 0 || lIndex >= LJMO_COUNT ) || (vIndex < 0 || vIndex >= VJMO_COUNT)) {
    119         return 0;
    120     }
    121 
    122     if (tIndex <= 0 || tIndex >= TJMO_COUNT) {
    123         tIndex = 0;
    124         result = 2;
    125     }
    126 
    127     syllable = (LEUnicode) ((lIndex * VJMO_COUNT + vIndex) * TJMO_COUNT + tIndex + HSYL_FIRST);
    128 
    129     return result;
    130 }
    131 
    132 static le_int32 decompose(LEUnicode syllable, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail)
    133 {
    134     le_int32 sIndex = syllable - HSYL_FIRST;
    135 
    136     if (sIndex < 0 || sIndex >= HSYL_COUNT) {
    137         return 0;
    138     }
    139 
    140     lead  = LJMO_FIRST + (sIndex / HSYL_LVCNT);
    141     vowel = VJMO_FIRST + (sIndex % HSYL_LVCNT) / TJMO_COUNT;
    142     trail = TJMO_FIRST + (sIndex % TJMO_COUNT);
    143 
    144     if (trail == TJMO_FIRST) {
    145         return 2;
    146     }
    147 
    148     return 3;
    149 }
    150 
    151 static le_int32 getCharClass(LEUnicode ch, LEUnicode &lead, LEUnicode &vowel, LEUnicode &trail)
    152 {
    153     lead  = LJMO_FILL;
    154     vowel = VJMO_FILL;
    155     trail = TJMO_FIRST;
    156 
    157     if (ch >= LJMO_FIRST && ch <= LJMO_LAST) {
    158         lead  = ch;
    159         return CC_L;
    160     }
    161 
    162     if (ch >= VJMO_FIRST && ch <= VJMO_LAST) {
    163         vowel = ch;
    164         return CC_V;
    165     }
    166 
    167     if (ch > TJMO_FIRST && ch <= TJMO_LAST) {
    168         trail = ch;
    169         return CC_T;
    170     }
    171 
    172     le_int32 c = decompose(ch, lead, vowel, trail);
    173 
    174     if (c == 2) {
    175         return CC_LV;
    176     }
    177 
    178     if (c == 3) {
    179         return CC_LVT;
    180     }
    181 
    182     trail = ch;
    183     return CC_X;
    184 }
    185 
    186 HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/,
    187                                        le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success)
    188     : OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, gsubTable, success)
    189 {
    190     fFeatureMap = featureMap;
    191     fFeatureMapCount = featureMapCount;
    192     fFeatureOrder = TRUE;
    193 }
    194 
    195 HangulOpenTypeLayoutEngine::HangulOpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 /*languageCode*/,
    196 			                                   le_int32 typoFlags, LEErrorCode &success)
    197     : OpenTypeLayoutEngine(fontInstance, scriptCode, korLanguageCode, typoFlags, success)
    198 {
    199     fFeatureMap = featureMap;
    200     fFeatureMapCount = featureMapCount;
    201     fFeatureOrder = TRUE;
    202 }
    203 
    204 HangulOpenTypeLayoutEngine::~HangulOpenTypeLayoutEngine()
    205 {
    206     // nothing to do
    207 }
    208 
    209 le_int32 HangulOpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
    210         LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success)
    211 {
    212     if (LE_FAILURE(success)) {
    213         return 0;
    214     }
    215 
    216     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
    217         success = LE_ILLEGAL_ARGUMENT_ERROR;
    218         return 0;
    219     }
    220 
    221     le_int32 worstCase = count * 3;
    222 
    223     outChars = LE_NEW_ARRAY(LEUnicode, worstCase);
    224 
    225     if (outChars == NULL) {
    226         success = LE_MEMORY_ALLOCATION_ERROR;
    227         return 0;
    228     }
    229 
    230     glyphStorage.allocateGlyphArray(worstCase, rightToLeft, success);
    231     glyphStorage.allocateAuxData(success);
    232 
    233     if (LE_FAILURE(success)) {
    234         LE_DELETE_ARRAY(outChars);
    235         return 0;
    236     }
    237 
    238     le_int32 outCharCount = 0;
    239     le_int32 limit = offset + count;
    240     le_int32 i = offset;
    241 
    242     while (i < limit) {
    243         le_int32 state    = 0;
    244         le_int32 inStart  = i;
    245         le_int32 outStart = outCharCount;
    246 
    247         while( i < limit) {
    248             LEUnicode lead  = 0;
    249             LEUnicode vowel = 0;
    250             LEUnicode trail = 0;
    251             int32_t chClass = getCharClass(chars[i], lead, vowel, trail);
    252             const StateTransition transition = stateTable[state][chClass];
    253 
    254             if (chClass == CC_X) {
    255                 /* Any character of type X will be stored as a trail jamo */
    256                 if ((transition.actionFlags & AF_T) != 0) {
    257                     outChars[outCharCount] = trail;
    258                     glyphStorage.setCharIndex(outCharCount, i-offset, success);
    259                     glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
    260                 }
    261             } else {
    262                 /* Any Hangul will be fully decomposed. Output the decomposed characters. */
    263                 if ((transition.actionFlags & AF_L) != 0) {
    264                     outChars[outCharCount] = lead;
    265                     glyphStorage.setCharIndex(outCharCount, i-offset, success);
    266                     glyphStorage.setAuxData(outCharCount++, ljmoFeatures, success);
    267                 }
    268 
    269                 if ((transition.actionFlags & AF_V) != 0) {
    270                     outChars[outCharCount] = vowel;
    271                     glyphStorage.setCharIndex(outCharCount, i-offset, success);
    272                     glyphStorage.setAuxData(outCharCount++, vjmoFeatures, success);
    273                 }
    274 
    275                 if ((transition.actionFlags & AF_T) != 0) {
    276                     outChars[outCharCount] = trail;
    277                     glyphStorage.setCharIndex(outCharCount, i-offset, success);
    278                     glyphStorage.setAuxData(outCharCount++, tjmoFeatures, success);
    279                 }
    280             }
    281 
    282             state = transition.newState;
    283 
    284             /* Negative next state means stop. */
    285             if (state < 0) {
    286                 break;
    287             }
    288 
    289             i += 1;
    290         }
    291 
    292         le_int32 inLength  = i - inStart;
    293         le_int32 outLength = outCharCount - outStart;
    294 
    295         /*
    296          * See if the syllable can be composed into a single character. There are 5
    297          * possible cases:
    298          *
    299          *   Input     Decomposed to    Compose to
    300          *   LV        L, V             LV
    301          *   LVT       L, V, T          LVT
    302          *   L, V      L, V             LV, DEL
    303          *   LV, T     L, V, T          LVT, DEL
    304          *   L, V, T   L, V, T          LVT, DEL, DEL
    305          */
    306         if ((inLength >= 1 && inLength <= 3) && (outLength == 2 || outLength == 3)) {
    307             LEUnicode syllable = 0x0000;
    308             LEUnicode lead  = outChars[outStart];
    309             LEUnicode vowel = outChars[outStart + 1];
    310             LEUnicode trail = outLength == 3? outChars[outStart + 2] : TJMO_FIRST;
    311 
    312             /*
    313              * If the composition consumes the whole decomposed syllable,
    314              * we can use it.
    315              */
    316             if (compose(lead, vowel, trail, syllable) == outLength) {
    317                 outCharCount = outStart;
    318                 outChars[outCharCount] = syllable;
    319                 glyphStorage.setCharIndex(outCharCount, inStart-offset, success);
    320                 glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
    321 
    322                 /*
    323                  * Replace the rest of the input characters with DEL.
    324                  */
    325                 for(le_int32 d = inStart + 1; d < i; d += 1) {
    326                     outChars[outCharCount] = 0xFFFF;
    327                     glyphStorage.setCharIndex(outCharCount, d - offset, success);
    328                     glyphStorage.setAuxData(outCharCount++, nullFeatures, success);
    329                 }
    330             }
    331         }
    332     }
    333 
    334     glyphStorage.adoptGlyphCount(outCharCount);
    335     return outCharCount;
    336 }
    337 
    338 U_NAMESPACE_END
    339