source/layout/LayoutEngine.cpp

   1 /*
   2  * (C) Copyright IBM Corp. and others 1998-2015 - All Rights Reserved
   3  */
   4
   5 #include "LETypes.h"
   6 #include "LEScripts.h"
   7 #include "LELanguages.h"
   8 #include "LESwaps.h"
   9
  10 #include "LayoutEngine.h"
  11 #include "ArabicLayoutEngine.h"
  12 #include "CanonShaping.h"
  13 #include "HanLayoutEngine.h"
  14 #include "HangulLayoutEngine.h"
  15 #include "IndicLayoutEngine.h"
  16 #include "KhmerLayoutEngine.h"
  17 #include "ThaiLayoutEngine.h"
  18 #include "TibetanLayoutEngine.h"
  19 #include "GXLayoutEngine.h"
  20 #include "GXLayoutEngine2.h"
  21
  22 #include "ScriptAndLanguageTags.h"
  23 #include "CharSubstitutionFilter.h"
  24
  25 #include "LEGlyphStorage.h"
  26
  27 #include "OpenTypeUtilities.h"
  28 #include "GlyphSubstitutionTables.h"
  29 #include "GlyphDefinitionTables.h"
  30 #include "MorphTables.h"
  31
  32 #include "DefaultCharMapper.h"
  33
  34 #include "KernTable.h"
  35
  36 U_NAMESPACE_BEGIN
  37
  38 /* Leave this copyright notice here! It needs to go somewhere in this library. */
  39 static const char copyright[] = U_COPYRIGHT_STRING;
  40
  41 /* TODO: remove these? */
  42 const le_int32 LayoutEngine::kTypoFlagKern = LE_Kerning_FEATURE_FLAG;
  43 const le_int32 LayoutEngine::kTypoFlagLiga = LE_Ligatures_FEATURE_FLAG;
  44
  45 const LEUnicode32 DefaultCharMapper::controlChars[] = {
  46     0x0009, 0x000A, 0x000D,
  47     /*0x200C, 0x200D,*/ 0x200E, 0x200F,
  48     0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E,
  49     0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F
  50 };
  51
  52 const le_int32 DefaultCharMapper::controlCharsCount = LE_ARRAY_SIZE(controlChars);
  53
  54 LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
  55 {
  56     (void)copyright;    // Suppress unused variable warning.
  57     if (fFilterControls) {
  58         le_int32 index = OpenTypeUtilities::search((le_uint32)ch, (le_uint32 *)controlChars, controlCharsCount);
  59
  60         if (controlChars[index] == ch) {
  61             return 0xFFFF;
  62         }
  63     }
  64
  65     if (fMirror) {
  66         le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)DefaultCharMapper::mirroredChars, DefaultCharMapper::mirroredCharsCount);
  67
  68         if (mirroredChars[index] == ch) {
  69             return DefaultCharMapper::srahCderorrim[index];
  70         }
  71     }
  72
  73     return ch;
  74 }
  75
  76 // This is here to get it out of LEGlyphFilter.h.
  77 // No particular reason to put it here, other than
  78 // this is a good central location...
  79 LEGlyphFilter::~LEGlyphFilter()
  80 {
  81     // nothing to do
  82 }
  83
  84 CharSubstitutionFilter::CharSubstitutionFilter(const LEFontInstance *fontInstance)
  85   : fFontInstance(fontInstance)
  86 {
  87     // nothing to do
  88 }
  89
  90 CharSubstitutionFilter::~CharSubstitutionFilter()
  91 {
  92     // nothing to do
  93 }
  94
  95 class CanonMarkFilter : public UMemory, public LEGlyphFilter
  96 {
  97 private:
  98   const LEReferenceTo<GlyphClassDefinitionTable> classDefTable;
  99
 100     CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class
 101     CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class
 102
 103 public:
 104     CanonMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success);
 105     virtual ~CanonMarkFilter();
 106
 107     virtual le_bool accept(LEGlyphID glyph) const;
 108 };
 109
 110 CanonMarkFilter::CanonMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success)
 111   : classDefTable(gdefTable->getMarkAttachClassDefinitionTable(gdefTable, success))
 112 {
 113 }
 114
 115 CanonMarkFilter::~CanonMarkFilter()
 116 {
 117     // nothing to do?
 118 }
 119
 120 le_bool CanonMarkFilter::accept(LEGlyphID glyph) const
 121 {
 122   LEErrorCode success = LE_NO_ERROR;
 123   le_int32 glyphClass = classDefTable->getGlyphClass(classDefTable, glyph, success);
 124   if(LE_FAILURE(success)) return false;
 125   return glyphClass != 0;
 126 }
 127
 128 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine)
 129
 130 #define ccmpFeatureTag  LE_CCMP_FEATURE_TAG
 131
 132 #define ccmpFeatureMask 0x80000000UL
 133
 134 #define canonFeatures (ccmpFeatureMask)
 135
 136 static const FeatureMap canonFeatureMap[] =
 137 {
 138     {ccmpFeatureTag, ccmpFeatureMask}
 139 };
 140
 141 static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap);
 142
 143 LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance,
 144                            le_int32 scriptCode,
 145                            le_int32 languageCode,
 146                            le_int32 typoFlags,
 147                            LEErrorCode &success)
 148   : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode),
 149     fTypoFlags(typoFlags), fFilterZeroWidth(TRUE)
 150 {
 151     if (LE_FAILURE(success)) {
 152         return;
 153     }
 154
 155     fGlyphStorage = new LEGlyphStorage();
 156     if (fGlyphStorage == NULL) {
 157         success = LE_MEMORY_ALLOCATION_ERROR;
 158     }
 159 }
 160
 161 le_int32 LayoutEngine::getGlyphCount() const
 162 {
 163     return fGlyphStorage->getGlyphCount();
 164 }
 165
 166 void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
 167 {
 168     fGlyphStorage->getCharIndices(charIndices, indexBase, success);
 169 }
 170
 171 void LayoutEngine::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const
 172 {
 173     fGlyphStorage->getCharIndices(charIndices, success);
 174 }
 175
 176 // Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits
 177 void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const
 178 {
 179     fGlyphStorage->getGlyphs(glyphs, extraBits, success);
 180 }
 181
 182 void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const
 183 {
 184     fGlyphStorage->getGlyphs(glyphs, success);
 185 }
 186
 187
 188 void LayoutEngine::getGlyphPositions(float positions[], LEErrorCode &success) const
 189 {
 190     fGlyphStorage->getGlyphPositions(positions, success);
 191 }
 192
 193 void LayoutEngine::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const
 194 {
 195     fGlyphStorage->getGlyphPosition(glyphIndex, x, y, success);
 196 }
 197
 198 le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 199                 LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success)
 200 {
 201     if (LE_FAILURE(success)) {
 202         return 0;
 203     }
 204
 205     if (offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 206         success = LE_ILLEGAL_ARGUMENT_ERROR;
 207         return 0;
 208     }
 209
 210     LEReferenceTo<GlyphSubstitutionTableHeader> canonGSUBTable((GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable);
 211     LETag scriptTag  = OpenTypeLayoutEngine::getScriptTag(fScriptCode);
 212     LETag langSysTag = OpenTypeLayoutEngine::getLangSysTag(fLanguageCode);
 213     le_int32 i, dir = 1, out = 0, outCharCount = count;
 214
 215     if (canonGSUBTable->coversScript(canonGSUBTable,scriptTag, success) || LE_SUCCESS(success)) {
 216         CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance);
 217         if (substitutionFilter == NULL) {
 218             success = LE_MEMORY_ALLOCATION_ERROR;
 219             return 0;
 220         }
 221
 222         const LEUnicode *inChars = &chars[offset];
 223         LEUnicode *reordered = NULL;
 224         LEGlyphStorage fakeGlyphStorage;
 225
 226         fakeGlyphStorage.allocateGlyphArray(count, rightToLeft, success);
 227
 228         if (LE_FAILURE(success)) {
 229             delete substitutionFilter;
 230             return 0;
 231         }
 232
 233         // This is the cheapest way to get mark reordering only for Hebrew.
 234         // We could just do the mark reordering for all scripts, but most
 235         // of them probably don't need it...
 236         if (fScriptCode == hebrScriptCode) {
 237           reordered = LE_NEW_ARRAY(LEUnicode, count);
 238
 239           if (reordered == NULL) {
 240             delete substitutionFilter;
 241             success = LE_MEMORY_ALLOCATION_ERROR;
 242             return 0;
 243           }
 244
 245           CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, fakeGlyphStorage);
 246           inChars = reordered;
 247         }
 248
 249         fakeGlyphStorage.allocateAuxData(success);
 250
 251         if (LE_FAILURE(success)) {
 252             delete substitutionFilter;
 253             return 0;
 254         }
 255
 256         if (rightToLeft) {
 257             out = count - 1;
 258             dir = -1;
 259         }
 260
 261         for (i = 0; i < count; i += 1, out += dir) {
 262             fakeGlyphStorage[out] = (LEGlyphID) inChars[i];
 263             fakeGlyphStorage.setAuxData(out, canonFeatures, success);
 264         }
 265
 266         if (reordered != NULL) {
 267           LE_DELETE_ARRAY(reordered);
 268         }
 269
 270         outCharCount = canonGSUBTable->process(canonGSUBTable, fakeGlyphStorage, rightToLeft, scriptTag, langSysTag, (const GlyphDefinitionTableHeader*)NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE, success);
 271
 272         if (LE_FAILURE(success)) {
 273             delete substitutionFilter;
 274             return 0;
 275         }
 276
 277         out = (rightToLeft? outCharCount - 1 : 0);
 278
 279         /*
 280          * The char indices array in fakeGlyphStorage has the correct mapping
 281          * back to the original input characters. Save it in glyphStorage. The
 282          * subsequent call to glyphStoratge.allocateGlyphArray will keep this
 283          * array rather than allocating and initializing a new one.
 284          */
 285         glyphStorage.adoptCharIndicesArray(fakeGlyphStorage);
 286
 287         outChars = LE_NEW_ARRAY(LEUnicode, outCharCount);
 288
 289         if (outChars == NULL) {
 290             delete substitutionFilter;
 291             success = LE_MEMORY_ALLOCATION_ERROR;
 292             return 0;
 293         }
 294
 295         for (i = 0; i < outCharCount; i += 1, out += dir) {
 296             outChars[out] = (LEUnicode) LE_GET_GLYPH(fakeGlyphStorage[i]);
 297         }
 298
 299         delete substitutionFilter;
 300     }
 301
 302     return outCharCount;
 303 }
 304
 305 le_int32 LayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 306                                             LEGlyphStorage &glyphStorage, LEErrorCode &success)
 307 {
 308     if (LE_FAILURE(success)) {
 309         return 0;
 310     }
 311
 312     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 313         success = LE_ILLEGAL_ARGUMENT_ERROR;
 314         return 0;
 315     }
 316
 317     LEUnicode *outChars = NULL;
 318     le_int32 outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success);
 319
 320     if (outChars != NULL) {
 321         mapCharsToGlyphs(outChars, 0, outCharCount, rightToLeft, rightToLeft, glyphStorage, success);
 322         LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work...
 323     } else {
 324         mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success);
 325     }
 326
 327     return glyphStorage.getGlyphCount();
 328 }
 329
 330 // Input: glyphs
 331 // Output: positions
 332 void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y, LEErrorCode &success)
 333 {
 334     if (LE_FAILURE(success)) {
 335         return;
 336     }
 337
 338     glyphStorage.allocatePositions(success);
 339
 340     if (LE_FAILURE(success)) {
 341         return;
 342     }
 343
 344     le_int32 i, glyphCount = glyphStorage.getGlyphCount();
 345
 346     for (i = 0; i < glyphCount; i += 1) {
 347         LEPoint advance;
 348
 349         glyphStorage.setPosition(i, x, y, success);
 350
 351         fFontInstance->getGlyphAdvance(glyphStorage[i], advance);
 352         x += advance.fX;
 353         y += advance.fY;
 354     }
 355
 356     glyphStorage.setPosition(glyphCount, x, y, success);
 357 }
 358
 359 void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool  reverse,
 360                                         LEGlyphStorage &glyphStorage, LEErrorCode &success)
 361 {
 362     if (LE_FAILURE(success)) {
 363         return;
 364     }
 365
 366     if (chars == NULL || offset < 0 || count < 0) {
 367         success = LE_ILLEGAL_ARGUMENT_ERROR;
 368         return;
 369     }
 370
 371     LEReferenceTo<GlyphDefinitionTableHeader> gdefTable((GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable,
 372                                                         CanonShaping::glyphDefinitionTableLen);
 373     CanonMarkFilter filter(gdefTable, success);
 374
 375     adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success);
 376
 377     if (fTypoFlags & LE_Kerning_FEATURE_FLAG) { /* kerning enabled */
 378       LETableReference kernTable(fFontInstance, LE_KERN_TABLE_TAG, success);
 379       KernTable kt(kernTable, success);
 380       kt.process(glyphStorage, success);
 381     }
 382
 383     // default is no adjustments
 384     return;
 385 }
 386
 387 void LayoutEngine::adjustMarkGlyphs(LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success)
 388 {
 389     float xAdjust = 0;
 390     le_int32 p, glyphCount = glyphStorage.getGlyphCount();
 391
 392     if (LE_FAILURE(success)) {
 393         return;
 394     }
 395
 396     if (markFilter == NULL) {
 397         success = LE_ILLEGAL_ARGUMENT_ERROR;
 398         return;
 399     }
 400
 401     float ignore, prev;
 402
 403     glyphStorage.getGlyphPosition(0, prev, ignore, success);
 404
 405     for (p = 0; p < glyphCount; p += 1) {
 406         float next, xAdvance;
 407
 408         glyphStorage.getGlyphPosition(p + 1, next, ignore, success);
 409
 410         xAdvance = next - prev;
 411         glyphStorage.adjustPosition(p, xAdjust, 0, success);
 412
 413         if (markFilter->accept(glyphStorage[p])) {
 414             xAdjust -= xAdvance;
 415         }
 416
 417         prev = next;
 418     }
 419
 420     glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success);
 421 }
 422
 423 void LayoutEngine::adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success)
 424 {
 425     float xAdjust = 0;
 426     le_int32 c = 0, direction = 1, p;
 427     le_int32 glyphCount = glyphStorage.getGlyphCount();
 428
 429     if (LE_FAILURE(success)) {
 430         return;
 431     }
 432
 433     if (markFilter == NULL) {
 434         success = LE_ILLEGAL_ARGUMENT_ERROR;
 435         return;
 436     }
 437
 438     if (reverse) {
 439         c = glyphCount - 1;
 440         direction = -1;
 441     }
 442
 443     float ignore, prev;
 444
 445     glyphStorage.getGlyphPosition(0, prev, ignore, success);
 446
 447     for (p = 0; p < charCount; p += 1, c += direction) {
 448         float next, xAdvance;
 449
 450         glyphStorage.getGlyphPosition(p + 1, next, ignore, success);
 451
 452         xAdvance = next - prev;
 453         glyphStorage.adjustPosition(p, xAdjust, 0, success);
 454
 455         if (markFilter->accept(chars[c])) {
 456             xAdjust -= xAdvance;
 457         }
 458
 459         prev = next;
 460     }
 461
 462     glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success);
 463 }
 464
 465 const void *LayoutEngine::getFontTable(LETag tableTag, size_t &length) const
 466 {
 467   return fFontInstance->getFontTable(tableTag, length);
 468 }
 469
 470 void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror,
 471                                     LEGlyphStorage &glyphStorage, LEErrorCode &success)
 472 {
 473     if (LE_FAILURE(success)) {
 474         return;
 475     }
 476
 477     glyphStorage.allocateGlyphArray(count, reverse, success);
 478
 479     DefaultCharMapper charMapper(TRUE, mirror);
 480
 481     fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage);
 482 }
 483
 484 // Input: characters, font?
 485 // Output: glyphs, positions, char indices
 486 // Returns: number of glyphs
 487 le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 488                               float x, float y, LEErrorCode &success)
 489 {
 490     if (LE_FAILURE(success)) {
 491         return 0;
 492     }
 493
 494     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 495         success = LE_ILLEGAL_ARGUMENT_ERROR;
 496         return 0;
 497     }
 498
 499     le_int32 glyphCount;
 500
 501     if (fGlyphStorage->getGlyphCount() > 0) {
 502         fGlyphStorage->reset();
 503     }
 504
 505     glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success);
 506     positionGlyphs(*fGlyphStorage, x, y, success);
 507     adjustGlyphPositions(chars, offset, count, rightToLeft, *fGlyphStorage, success);
 508
 509     return glyphCount;
 510 }
 511
 512 void LayoutEngine::reset()
 513 {
 514   if(fGlyphStorage!=NULL) {
 515     fGlyphStorage->reset();
 516   }
 517 }
 518
 519 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success)
 520 {
 521   //kerning and ligatures - by default
 522   return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, languageCode, LE_DEFAULT_FEATURE_FLAG, success);
 523 }
 524
 525 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success)
 526 {
 527     static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG;
 528     static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG;
 529     static const le_uint32 morxTableTag = LE_MORX_TABLE_TAG;
 530
 531     if (LE_FAILURE(success)) {
 532         return NULL;
 533     }
 534
 535     LEReferenceTo<GlyphSubstitutionTableHeader> gsubTable(fontInstance,gsubTableTag,success);
 536     LayoutEngine *result = NULL;
 537     LETag scriptTag   = 0x00000000;
 538     LETag languageTag = 0x00000000;
 539     LETag v2ScriptTag = OpenTypeLayoutEngine::getV2ScriptTag(scriptCode);
 540
 541     // Right now, only invoke V2 processing for Devanagari.  TODO: Allow more V2 scripts as they are
 542     // properly tested.
 543
 544     if ( v2ScriptTag == dev2ScriptTag && gsubTable.isValid() && gsubTable->coversScript(gsubTable, v2ScriptTag, success )) {
 545       result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, TRUE, gsubTable, success);
 546     }
 547     else if (gsubTable.isValid() && gsubTable->coversScript(gsubTable, scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode), success)) {
 548         switch (scriptCode) {
 549         case bengScriptCode:
 550         case devaScriptCode:
 551         case gujrScriptCode:
 552         case kndaScriptCode:
 553         case mlymScriptCode:
 554         case oryaScriptCode:
 555         case guruScriptCode:
 556         case tamlScriptCode:
 557         case teluScriptCode:
 558         case sinhScriptCode:
 559             result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, FALSE, gsubTable, success);
 560             break;
 561
 562         case arabScriptCode:
 563             result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 564             break;
 565
 566         case hebrScriptCode:
 567             // Disable hebrew ligatures since they have only archaic uses, see ticket #8318
 568             result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags & ~kTypoFlagLiga, gsubTable, success);
 569             break;
 570
 571         case hangScriptCode:
 572             result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 573             break;
 574
 575         case haniScriptCode:
 576             languageTag = OpenTypeLayoutEngine::getLangSysTag(languageCode);
 577
 578             switch (languageCode) {
 579             case korLanguageCode:
 580             case janLanguageCode:
 581             case zhtLanguageCode:
 582             case zhsLanguageCode:
 583               if (gsubTable->coversScriptAndLanguage(gsubTable, scriptTag, languageTag, success, TRUE)) {
 584                     result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 585                     break;
 586               }
 587
 588                 // note: falling through to default case.
 589             default:
 590                 result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 591                 break;
 592             }
 593
 594             break;
 595
 596         case tibtScriptCode:
 597             result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 598             break;
 599
 600         case khmrScriptCode:
 601             result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 602             break;
 603
 604         default:
 605             result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 606             break;
 607         }
 608     } else {
 609         LEReferenceTo<MorphTableHeader2> morxTable(fontInstance, morxTableTag, success);
 610         if (LE_SUCCESS(success) && morxTable.isValid() && SWAPL(morxTable->version)==0x00020000) {
 611           result = new GXLayoutEngine2(fontInstance, scriptCode, languageCode, morxTable, typoFlags, success);
 612         } else {
 613           LEReferenceTo<MorphTableHeader> mortTable(fontInstance, mortTableTag, success);
 614           if (LE_SUCCESS(success) && mortTable.isValid() && SWAPL(mortTable->version)==0x00010000) { // mort
 615             result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, mortTable, success);
 616             } else {
 617                 switch (scriptCode) {
 618                     case bengScriptCode:
 619                     case devaScriptCode:
 620                     case gujrScriptCode:
 621                     case kndaScriptCode:
 622                     case mlymScriptCode:
 623                     case oryaScriptCode:
 624                     case guruScriptCode:
 625                     case tamlScriptCode:
 626                     case teluScriptCode:
 627                     case sinhScriptCode:
 628                     {
 629                         result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 630                         break;
 631                     }
 632
 633                     case arabScriptCode:
 634                         //case hebrScriptCode:
 635                         result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 636                         break;
 637
 638                         //case hebrScriptCode:
 639                         //    return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);
 640
 641                     case thaiScriptCode:
 642                         result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 643                         break;
 644
 645                     case hangScriptCode:
 646                         result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 647                         break;
 648
 649                     default:
 650                         result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 651                         break;
 652                 }
 653             }
 654         }
 655     }
 656
 657     if (result && LE_FAILURE(success)) {
 658                 delete result;
 659                 result = NULL;
 660         }
 661
 662     if (result == NULL) {
 663         success = LE_MEMORY_ALLOCATION_ERROR;
 664     }
 665
 666     return result;
 667 }
 668
 669 LayoutEngine::~LayoutEngine() {
 670     delete fGlyphStorage;
 671 }
 672
 673 U_NAMESPACE_END