icuSources/layout/OpenTypeLayoutEngine.cpp

   1
   2 /*
   3  *
   4  * (C) Copyright IBM Corp. and others 1998-2013 - All Rights Reserved
   5  *
   6  */
   7
   8 #include "LETypes.h"
   9 #include "LEScripts.h"
  10 #include "LELanguages.h"
  11
  12 #include "LayoutEngine.h"
  13 #include "CanonShaping.h"
  14 #include "OpenTypeLayoutEngine.h"
  15 #include "ScriptAndLanguageTags.h"
  16 #include "CharSubstitutionFilter.h"
  17
  18 #include "GlyphSubstitutionTables.h"
  19 #include "GlyphDefinitionTables.h"
  20 #include "GlyphPositioningTables.h"
  21
  22 #include "LEGlyphStorage.h"
  23 #include "GlyphPositionAdjustments.h"
  24
  25 #include "GDEFMarkFilter.h"
  26
  27 #include "KernTable.h"
  28
  29 U_NAMESPACE_BEGIN
  30
  31 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(OpenTypeLayoutEngine)
  32
  33 #define ccmpFeatureTag LE_CCMP_FEATURE_TAG
  34 #define ligaFeatureTag LE_LIGA_FEATURE_TAG
  35 #define cligFeatureTag LE_CLIG_FEATURE_TAG
  36 #define kernFeatureTag LE_KERN_FEATURE_TAG
  37 #define markFeatureTag LE_MARK_FEATURE_TAG
  38 #define mkmkFeatureTag LE_MKMK_FEATURE_TAG
  39 #define loclFeatureTag LE_LOCL_FEATURE_TAG
  40 #define caltFeatureTag LE_CALT_FEATURE_TAG
  41
  42 #define dligFeatureTag LE_DLIG_FEATURE_TAG
  43 #define rligFeatureTag LE_RLIG_FEATURE_TAG
  44 #define paltFeatureTag LE_PALT_FEATURE_TAG
  45
  46 #define hligFeatureTag LE_HLIG_FEATURE_TAG
  47 #define smcpFeatureTag LE_SMCP_FEATURE_TAG
  48 #define fracFeatureTag LE_FRAC_FEATURE_TAG
  49 #define afrcFeatureTag LE_AFRC_FEATURE_TAG
  50 #define zeroFeatureTag LE_ZERO_FEATURE_TAG
  51 #define swshFeatureTag LE_SWSH_FEATURE_TAG
  52 #define cswhFeatureTag LE_CSWH_FEATURE_TAG
  53 #define saltFeatureTag LE_SALT_FEATURE_TAG
  54 #define naltFeatureTag LE_NALT_FEATURE_TAG
  55 #define rubyFeatureTag LE_RUBY_FEATURE_TAG
  56 #define ss01FeatureTag LE_SS01_FEATURE_TAG
  57 #define ss02FeatureTag LE_SS02_FEATURE_TAG
  58 #define ss03FeatureTag LE_SS03_FEATURE_TAG
  59 #define ss04FeatureTag LE_SS04_FEATURE_TAG
  60 #define ss05FeatureTag LE_SS05_FEATURE_TAG
  61 #define ss06FeatureTag LE_SS06_FEATURE_TAG
  62 #define ss07FeatureTag LE_SS07_FEATURE_TAG
  63
  64 #define ccmpFeatureMask 0x80000000UL
  65 #define ligaFeatureMask 0x40000000UL
  66 #define cligFeatureMask 0x20000000UL
  67 #define kernFeatureMask 0x10000000UL
  68 #define paltFeatureMask 0x08000000UL
  69 #define markFeatureMask 0x04000000UL
  70 #define mkmkFeatureMask 0x02000000UL
  71 #define loclFeatureMask 0x01000000UL
  72 #define caltFeatureMask 0x00800000UL
  73
  74 #define dligFeatureMask 0x00400000UL
  75 #define rligFeatureMask 0x00200000UL
  76 #define hligFeatureMask 0x00100000UL
  77 #define smcpFeatureMask 0x00080000UL
  78 #define fracFeatureMask 0x00040000UL
  79 #define afrcFeatureMask 0x00020000UL
  80 #define zeroFeatureMask 0x00010000UL
  81 #define swshFeatureMask 0x00008000UL
  82 #define cswhFeatureMask 0x00004000UL
  83 #define saltFeatureMask 0x00002000UL
  84 #define naltFeatureMask 0x00001000UL
  85 #define rubyFeatureMask 0x00000800UL
  86 #define ss01FeatureMask 0x00000400UL
  87 #define ss02FeatureMask 0x00000200UL
  88 #define ss03FeatureMask 0x00000100UL
  89 #define ss04FeatureMask 0x00000080UL
  90 #define ss05FeatureMask 0x00000040UL
  91 #define ss06FeatureMask 0x00000020UL
  92 #define ss07FeatureMask 0x00000010UL
  93
  94 #define minimalFeatures     (ccmpFeatureMask | markFeatureMask | mkmkFeatureMask | loclFeatureMask | caltFeatureMask)
  95
  96 static const FeatureMap featureMap[] =
  97 {
  98     {ccmpFeatureTag, ccmpFeatureMask},
  99     {ligaFeatureTag, ligaFeatureMask},
 100     {cligFeatureTag, cligFeatureMask},
 101     {kernFeatureTag, kernFeatureMask},
 102     {paltFeatureTag, paltFeatureMask},
 103     {markFeatureTag, markFeatureMask},
 104     {mkmkFeatureTag, mkmkFeatureMask},
 105     {loclFeatureTag, loclFeatureMask},
 106     {caltFeatureTag, caltFeatureMask},
 107     {hligFeatureTag, hligFeatureMask},
 108     {smcpFeatureTag, smcpFeatureMask},
 109     {fracFeatureTag, fracFeatureMask},
 110     {afrcFeatureTag, afrcFeatureMask},
 111     {zeroFeatureTag, zeroFeatureMask},
 112     {swshFeatureTag, swshFeatureMask},
 113     {cswhFeatureTag, cswhFeatureMask},
 114     {saltFeatureTag, saltFeatureMask},
 115     {naltFeatureTag, naltFeatureMask},
 116     {rubyFeatureTag, rubyFeatureMask},
 117     {ss01FeatureTag, ss01FeatureMask},
 118     {ss02FeatureTag, ss02FeatureMask},
 119     {ss03FeatureTag, ss03FeatureMask},
 120     {ss04FeatureTag, ss04FeatureMask},
 121     {ss05FeatureTag, ss05FeatureMask},
 122     {ss06FeatureTag, ss06FeatureMask},
 123     {ss07FeatureTag, ss07FeatureMask}
 124 };
 125
 126 static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
 127
 128 OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode,
 129                         le_int32 typoFlags, const GlyphSubstitutionTableHeader *gsubTable, LEErrorCode &success)
 130     : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureMask(minimalFeatures),
 131       fFeatureMap(featureMap), fFeatureMapCount(featureMapCount), fFeatureOrder(FALSE),
 132       fGSUBTable(gsubTable), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL)
 133 {
 134     static const le_uint32 gdefTableTag = LE_GDEF_TABLE_TAG;
 135     static const le_uint32 gposTableTag = LE_GPOS_TABLE_TAG;
 136     const GlyphPositioningTableHeader *gposTable = (const GlyphPositioningTableHeader *) getFontTable(gposTableTag);
 137
 138     switch (typoFlags & (LE_SS01_FEATURE_FLAG
 139                          | LE_SS02_FEATURE_FLAG
 140                          | LE_SS03_FEATURE_FLAG
 141                          | LE_SS04_FEATURE_FLAG
 142                          | LE_SS05_FEATURE_FLAG
 143                          | LE_SS06_FEATURE_FLAG
 144                          | LE_SS07_FEATURE_FLAG)) {
 145         case LE_SS01_FEATURE_FLAG:
 146             fFeatureMask |= ss01FeatureMask;
 147             break;
 148         case LE_SS02_FEATURE_FLAG:
 149             fFeatureMask |= ss02FeatureMask;
 150             break;
 151         case LE_SS03_FEATURE_FLAG:
 152             fFeatureMask |= ss03FeatureMask;
 153             break;
 154         case LE_SS04_FEATURE_FLAG:
 155             fFeatureMask |= ss04FeatureMask;
 156             break;
 157         case LE_SS05_FEATURE_FLAG:
 158             fFeatureMask |= ss05FeatureMask;
 159             break;
 160         case LE_SS06_FEATURE_FLAG:
 161             fFeatureMask |= ss06FeatureMask;
 162             break;
 163         case LE_SS07_FEATURE_FLAG:
 164             fFeatureMask |= ss07FeatureMask;
 165             break;
 166     }
 167
 168     if (typoFlags & LE_Kerning_FEATURE_FLAG) {
 169       fFeatureMask |= (kernFeatureMask | paltFeatureMask);
 170       // Convenience.
 171     }
 172     if (typoFlags & LE_Ligatures_FEATURE_FLAG) {
 173       fFeatureMask |= (ligaFeatureMask | cligFeatureMask);
 174       // Convenience TODO: should add: .. dligFeatureMask | rligFeatureMask ?
 175     }
 176     if (typoFlags & LE_CLIG_FEATURE_FLAG) fFeatureMask |= cligFeatureMask;
 177     if (typoFlags & LE_DLIG_FEATURE_FLAG) fFeatureMask |= dligFeatureMask;
 178     if (typoFlags & LE_HLIG_FEATURE_FLAG) fFeatureMask |= hligFeatureMask;
 179     if (typoFlags & LE_LIGA_FEATURE_FLAG) fFeatureMask |= ligaFeatureMask;
 180     if (typoFlags & LE_RLIG_FEATURE_FLAG) fFeatureMask |= rligFeatureMask;
 181     if (typoFlags & LE_SMCP_FEATURE_FLAG) fFeatureMask |= smcpFeatureMask;
 182     if (typoFlags & LE_FRAC_FEATURE_FLAG) fFeatureMask |= fracFeatureMask;
 183     if (typoFlags & LE_AFRC_FEATURE_FLAG) fFeatureMask |= afrcFeatureMask;
 184     if (typoFlags & LE_ZERO_FEATURE_FLAG) fFeatureMask |= zeroFeatureMask;
 185     if (typoFlags & LE_SWSH_FEATURE_FLAG) fFeatureMask |= swshFeatureMask;
 186     if (typoFlags & LE_CSWH_FEATURE_FLAG) fFeatureMask |= cswhFeatureMask;
 187     if (typoFlags & LE_SALT_FEATURE_FLAG) fFeatureMask |= saltFeatureMask;
 188     if (typoFlags & LE_RUBY_FEATURE_FLAG) fFeatureMask |= rubyFeatureMask;
 189     if (typoFlags & LE_NALT_FEATURE_FLAG) {
 190       // Mutually exclusive with ALL other features. http://www.microsoft.com/typography/otspec/features_ko.htm
 191       fFeatureMask = naltFeatureMask;
 192     }
 193
 194     if (typoFlags & LE_CHAR_FILTER_FEATURE_FLAG) {
 195       // This isn't a font feature, but requests a Char Substitution Filter
 196       fSubstitutionFilter = new CharSubstitutionFilter(fontInstance);
 197     }
 198
 199     setScriptAndLanguageTags();
 200
 201     fGDEFTable = (const GlyphDefinitionTableHeader *) getFontTable(gdefTableTag);
 202
 203 // JK patch, 2008-05-30 - see Sinhala bug report and LKLUG font
 204 //    if (gposTable != NULL && gposTable->coversScriptAndLanguage(fScriptTag, fLangSysTag)) {
 205     if (gposTable != NULL && gposTable->coversScript(fScriptTag)) {
 206         fGPOSTable = gposTable;
 207     }
 208 }
 209
 210 void OpenTypeLayoutEngine::reset()
 211 {
 212     // NOTE: if we're called from
 213     // the destructor, LayoutEngine;:reset()
 214     // will have been called already by
 215     // LayoutEngine::~LayoutEngine()
 216     LayoutEngine::reset();
 217 }
 218
 219 OpenTypeLayoutEngine::OpenTypeLayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode,
 220                        le_int32 typoFlags, LEErrorCode &success)
 221     : LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success), fFeatureOrder(FALSE),
 222       fGSUBTable(NULL), fGDEFTable(NULL), fGPOSTable(NULL), fSubstitutionFilter(NULL)
 223 {
 224     setScriptAndLanguageTags();
 225 }
 226
 227 OpenTypeLayoutEngine::~OpenTypeLayoutEngine()
 228 {
 229     if (fTypoFlags & 0x80000000L) {
 230         delete fSubstitutionFilter;
 231     }
 232
 233     reset();
 234 }
 235
 236 LETag OpenTypeLayoutEngine::getScriptTag(le_int32 scriptCode)
 237 {
 238     if (scriptCode < 0 || scriptCode >= scriptCodeCount) {
 239         return 0xFFFFFFFF;
 240     }
 241     return scriptTags[scriptCode];
 242 }
 243
 244 LETag OpenTypeLayoutEngine::getV2ScriptTag(le_int32 scriptCode)
 245 {
 246         switch (scriptCode) {
 247                 case bengScriptCode :    return bng2ScriptTag;
 248                 case devaScriptCode :    return dev2ScriptTag;
 249                 case gujrScriptCode :    return gjr2ScriptTag;
 250                 case guruScriptCode :    return gur2ScriptTag;
 251                 case kndaScriptCode :    return knd2ScriptTag;
 252                 case mlymScriptCode :    return mlm2ScriptTag;
 253                 case oryaScriptCode :    return ory2ScriptTag;
 254                 case tamlScriptCode :    return tml2ScriptTag;
 255                 case teluScriptCode :    return tel2ScriptTag;
 256                 default:                 return nullScriptTag;
 257         }
 258 }
 259
 260 LETag OpenTypeLayoutEngine::getLangSysTag(le_int32 languageCode)
 261 {
 262     if (languageCode < 0 || languageCode >= languageCodeCount) {
 263         return 0xFFFFFFFF;
 264     }
 265
 266     return languageTags[languageCode];
 267 }
 268
 269 void OpenTypeLayoutEngine::setScriptAndLanguageTags()
 270 {
 271     fScriptTag  = getScriptTag(fScriptCode);
 272     fScriptTagV2 = getV2ScriptTag(fScriptCode);
 273     fLangSysTag = getLangSysTag(fLanguageCode);
 274 }
 275
 276 le_int32 OpenTypeLayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 277                 LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success)
 278 {
 279     if (LE_FAILURE(success)) {
 280         return 0;
 281     }
 282
 283     if (offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 284         success = LE_ILLEGAL_ARGUMENT_ERROR;
 285         return 0;
 286     }
 287
 288     // This is the cheapest way to get mark reordering only for Hebrew.
 289     // We could just do the mark reordering for all scripts, but most
 290     // of them probably don't need it... Another option would be to
 291     // add a HebrewOpenTypeLayoutEngine subclass, but the only thing it
 292     // would need to do is mark reordering, so that seems like overkill.
 293     if (fScriptCode == hebrScriptCode) {
 294         outChars = LE_NEW_ARRAY(LEUnicode, count);
 295
 296         if (outChars == NULL) {
 297             success = LE_MEMORY_ALLOCATION_ERROR;
 298             return 0;
 299         }
 300
 301         if (LE_FAILURE(success)) {
 302             LE_DELETE_ARRAY(outChars);
 303             return 0;
 304         }
 305
 306         CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, outChars, glyphStorage);
 307     }
 308
 309     if (LE_FAILURE(success)) {
 310         return 0;
 311     }
 312
 313     glyphStorage.allocateGlyphArray(count, rightToLeft, success);
 314     glyphStorage.allocateAuxData(success);
 315
 316     for (le_int32 i = 0; i < count; i += 1) {
 317         glyphStorage.setAuxData(i, fFeatureMask, success);
 318     }
 319
 320     return count;
 321 }
 322
 323 // Input: characters, tags
 324 // Output: glyphs, char indices
 325 le_int32 OpenTypeLayoutEngine::glyphProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 326                                                LEGlyphStorage &glyphStorage, LEErrorCode &success)
 327 {
 328     if (LE_FAILURE(success)) {
 329         return 0;
 330     }
 331
 332     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 333         success = LE_ILLEGAL_ARGUMENT_ERROR;
 334         return 0;
 335     }
 336
 337     mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success);
 338
 339     if (LE_FAILURE(success)) {
 340         return 0;
 341     }
 342
 343     if (fGSUBTable != NULL) {
 344         if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) {
 345             count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter,
 346                                     fFeatureMap, fFeatureMapCount, fFeatureOrder, success);
 347
 348         } else {
 349         count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter,
 350                                     fFeatureMap, fFeatureMapCount, fFeatureOrder, success);
 351         }
 352     }
 353
 354     return count;
 355 }
 356 // Input: characters, tags
 357 // Output: glyphs, char indices
 358 le_int32 OpenTypeLayoutEngine::glyphSubstitution(le_int32 count, le_int32 max, le_bool rightToLeft,
 359                                                LEGlyphStorage &glyphStorage, LEErrorCode &success)
 360 {
 361     if (LE_FAILURE(success)) {
 362         return 0;
 363     }
 364
 365     if ( count < 0 || max < 0 ) {
 366         success = LE_ILLEGAL_ARGUMENT_ERROR;
 367         return 0;
 368     }
 369
 370     if (fGSUBTable != NULL) {
 371         if (fScriptTagV2 != nullScriptTag && fGSUBTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) {
 372             count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTagV2, fLangSysTag, fGDEFTable, fSubstitutionFilter,
 373                                     fFeatureMap, fFeatureMapCount, fFeatureOrder, success);
 374
 375         } else {
 376         count = fGSUBTable->process(glyphStorage, rightToLeft, fScriptTag, fLangSysTag, fGDEFTable, fSubstitutionFilter,
 377                                     fFeatureMap, fFeatureMapCount, fFeatureOrder, success);
 378         }
 379     }
 380
 381     return count;
 382 }
 383 le_int32 OpenTypeLayoutEngine::glyphPostProcessing(LEGlyphStorage &tempGlyphStorage, LEGlyphStorage &glyphStorage, LEErrorCode &success)
 384 {
 385     if (LE_FAILURE(success)) {
 386         return 0;
 387     }
 388
 389     glyphStorage.adoptGlyphArray(tempGlyphStorage);
 390     glyphStorage.adoptCharIndicesArray(tempGlyphStorage);
 391     glyphStorage.adoptAuxDataArray(tempGlyphStorage);
 392     glyphStorage.adoptGlyphCount(tempGlyphStorage);
 393
 394     return glyphStorage.getGlyphCount();
 395 }
 396
 397 le_int32 OpenTypeLayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft, LEGlyphStorage &glyphStorage, LEErrorCode &success)
 398 {
 399     LEUnicode *outChars = NULL;
 400     LEGlyphStorage fakeGlyphStorage;
 401     le_int32 outCharCount, outGlyphCount;
 402
 403     if (LE_FAILURE(success)) {
 404         return 0;
 405     }
 406
 407     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 408         success = LE_ILLEGAL_ARGUMENT_ERROR;
 409         return 0;
 410     }
 411
 412     outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, fakeGlyphStorage, success);
 413
 414     if (LE_FAILURE(success)) {
 415         return 0;
 416     }
 417
 418     if (outChars != NULL) {
 419         // le_int32 fakeGlyphCount =
 420         glyphProcessing(outChars, 0, outCharCount, outCharCount, rightToLeft, fakeGlyphStorage, success);
 421         LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work...
 422         //adjustGlyphs(outChars, 0, outCharCount, rightToLeft, fakeGlyphs, fakeGlyphCount);
 423     } else {
 424         // le_int32 fakeGlyphCount =
 425         glyphProcessing(chars, offset, count, max, rightToLeft, fakeGlyphStorage, success);
 426         //adjustGlyphs(chars, offset, count, rightToLeft, fakeGlyphs, fakeGlyphCount);
 427     }
 428
 429     if (LE_FAILURE(success)) {
 430         return 0;
 431     }
 432
 433     outGlyphCount = glyphPostProcessing(fakeGlyphStorage, glyphStorage, success);
 434
 435     return outGlyphCount;
 436 }
 437
 438 // apply GPOS table, if any
 439 void OpenTypeLayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse,
 440                                                 LEGlyphStorage &glyphStorage, LEErrorCode &success)
 441 {
 442     if (LE_FAILURE(success)) {
 443         return;
 444     }
 445
 446     if (chars == NULL || offset < 0 || count < 0) {
 447         success = LE_ILLEGAL_ARGUMENT_ERROR;
 448         return;
 449     }
 450
 451     le_int32 glyphCount = glyphStorage.getGlyphCount();
 452     if (glyphCount == 0) {
 453         return;
 454     }
 455
 456     if (fGPOSTable != NULL) {
 457         GlyphPositionAdjustments *adjustments = new GlyphPositionAdjustments(glyphCount);
 458         le_int32 i;
 459
 460         if (adjustments == NULL) {
 461             success = LE_MEMORY_ALLOCATION_ERROR;
 462             return;
 463         }
 464
 465 #if 0
 466         // Don't need to do this if we allocate
 467         // the adjustments array w/ new...
 468         for (i = 0; i < glyphCount; i += 1) {
 469             adjustments->setXPlacement(i, 0);
 470             adjustments->setYPlacement(i, 0);
 471
 472             adjustments->setXAdvance(i, 0);
 473             adjustments->setYAdvance(i, 0);
 474
 475             adjustments->setBaseOffset(i, -1);
 476         }
 477 #endif
 478
 479         if (fGPOSTable != NULL) {
 480             if (fScriptTagV2 != nullScriptTag && fGPOSTable->coversScriptAndLanguage(fScriptTagV2,fLangSysTag)) {
 481                 fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTagV2, fLangSysTag, fGDEFTable, success, fFontInstance,
 482                                 fFeatureMap, fFeatureMapCount, fFeatureOrder);
 483
 484             } else {
 485                 fGPOSTable->process(glyphStorage, adjustments, reverse, fScriptTag, fLangSysTag, fGDEFTable, success, fFontInstance,
 486                                 fFeatureMap, fFeatureMapCount, fFeatureOrder);
 487             }
 488         } else if ( fTypoFlags & 0x1 ) {
 489             static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG;
 490             KernTable kt(fFontInstance, getFontTable(kernTableTag));
 491             kt.process(glyphStorage);
 492         }
 493
 494         float xAdjust = 0, yAdjust = 0;
 495
 496         for (i = 0; i < glyphCount; i += 1) {
 497             float xAdvance   = adjustments->getXAdvance(i);
 498             float yAdvance   = adjustments->getYAdvance(i);
 499             float xPlacement = 0;
 500             float yPlacement = 0;
 501
 502
 503 #if 0
 504             // This is where separate kerning adjustments
 505             // should get applied.
 506             xAdjust += xKerning;
 507             yAdjust += yKerning;
 508 #endif
 509
 510             for (le_int32 base = i; base >= 0; base = adjustments->getBaseOffset(base)) {
 511                 xPlacement += adjustments->getXPlacement(base);
 512                 yPlacement += adjustments->getYPlacement(base);
 513             }
 514
 515             xPlacement = fFontInstance->xUnitsToPoints(xPlacement);
 516             yPlacement = fFontInstance->yUnitsToPoints(yPlacement);
 517             glyphStorage.adjustPosition(i, xAdjust + xPlacement, -(yAdjust + yPlacement), success);
 518
 519             xAdjust += fFontInstance->xUnitsToPoints(xAdvance);
 520             yAdjust += fFontInstance->yUnitsToPoints(yAdvance);
 521         }
 522
 523         glyphStorage.adjustPosition(glyphCount, xAdjust, -yAdjust, success);
 524
 525         delete adjustments;
 526     } else {
 527         // if there was no GPOS table, maybe there's non-OpenType kerning we can use
 528         LayoutEngine::adjustGlyphPositions(chars, offset, count, reverse, glyphStorage, success);
 529     }
 530
 531     LEGlyphID zwnj  = fFontInstance->mapCharToGlyph(0x200C);
 532
 533     if (zwnj != 0x0000) {
 534         for (le_int32 g = 0; g < glyphCount; g += 1) {
 535             LEGlyphID glyph = glyphStorage[g];
 536
 537             if (glyph == zwnj) {
 538                 glyphStorage[g] = LE_SET_GLYPH(glyph, 0xFFFF);
 539             }
 540         }
 541     }
 542
 543 #if 0
 544     // Don't know why this is here...
 545     LE_DELETE_ARRAY(fFeatureTags);
 546     fFeatureTags = NULL;
 547 #endif
 548 }
 549
 550 U_NAMESPACE_END