icuSources/layout/LayoutEngine.cpp

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