1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 
  27 /*
  28  *
  29  * (C) Copyright IBM Corp. 1998-2005 - All Rights Reserved
  30  *
  31  */
  32 
  33 #include "LETypes.h"
  34 #include "LEScripts.h"
  35 #include "LELanguages.h"
  36 #include "LESwaps.h"
  37 
  38 #include "LayoutEngine.h"
  39 #include "ArabicLayoutEngine.h"
  40 #include "CanonShaping.h"
  41 #include "HanLayoutEngine.h"
  42 #include "HangulLayoutEngine.h"
  43 #include "IndicLayoutEngine.h"
  44 #include "KhmerLayoutEngine.h"
  45 #include "ThaiLayoutEngine.h"
  46 #include "TibetanLayoutEngine.h"
  47 #include "GXLayoutEngine.h"
  48 #include "GXLayoutEngine2.h"
  49 
  50 #include "ScriptAndLanguageTags.h"
  51 #include "CharSubstitutionFilter.h"
  52 
  53 #include "LEGlyphStorage.h"
  54 
  55 #include "OpenTypeUtilities.h"
  56 #include "GlyphSubstitutionTables.h"
  57 #include "GlyphDefinitionTables.h"
  58 #include "MorphTables.h"
  59 
  60 #include "DefaultCharMapper.h"
  61 
  62 #include "KernTable.h"
  63 
  64 U_NAMESPACE_BEGIN
  65 
  66 /* Leave this copyright notice here! It needs to go somewhere in this library. */
  67 static const char copyright[] = U_COPYRIGHT_STRING;
  68 
  69 /* TODO: remove these? */
  70 const le_int32 LayoutEngine::kTypoFlagKern = LE_Kerning_FEATURE_FLAG;
  71 const le_int32 LayoutEngine::kTypoFlagLiga = LE_Ligatures_FEATURE_FLAG;
  72 
  73 const LEUnicode32 DefaultCharMapper::controlChars[] = {
  74     0x0009, 0x000A, 0x000D,
  75     /*0x200C, 0x200D,*/ 0x200E, 0x200F,
  76     0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E,
  77     0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F
  78 };
  79 
  80 const le_int32 DefaultCharMapper::controlCharsCount = LE_ARRAY_SIZE(controlChars);
  81 
  82 const LEUnicode32 DefaultCharMapper::controlCharsZWJ[] = {
  83     0x0009, 0x000A, 0x000D,
  84     0x200C, 0x200D, 0x200E, 0x200F,
  85     0x2028, 0x2029, 0x202A, 0x202B, 0x202C, 0x202D, 0x202E,
  86     0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F
  87 };
  88 
  89 const le_int32 DefaultCharMapper::controlCharsZWJCount = LE_ARRAY_SIZE(controlCharsZWJ);
  90 
  91 LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
  92 {
  93     if (fZWJ) {
  94         if (ch < 0x20) {
  95             if (ch == 0x0a || ch == 0x0d || ch == 0x09) {
  96                 return 0xffff;
  97             }
  98         } else if (ch >= 0x200c && ch <= 0x206f) {
  99             le_int32 index = OpenTypeUtilities::search((le_uint32)ch,
 100                                                        (le_uint32 *)controlCharsZWJ,
 101                                                        controlCharsZWJCount);
 102             if (controlCharsZWJ[index] == ch) {
 103                 return 0xffff;
 104             }
 105         }
 106         return ch; // note ZWJ bypasses fFilterControls and fMirror
 107     }
 108 
 109     if (fFilterControls) {
 110         le_int32 index = OpenTypeUtilities::search((le_uint32)ch, (le_uint32 *)controlChars, controlCharsCount);
 111 
 112         if (controlChars[index] == ch) {
 113             return 0xFFFF;
 114         }
 115     }
 116 
 117     if (fMirror) {
 118         le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)DefaultCharMapper::mirroredChars, DefaultCharMapper::mirroredCharsCount);
 119 
 120         if (mirroredChars[index] == ch) {
 121             return DefaultCharMapper::srahCderorrim[index];
 122         }
 123     }
 124 
 125     return ch;
 126 }
 127 
 128 // This is here to get it out of LEGlyphFilter.h.
 129 // No particular reason to put it here, other than
 130 // this is a good central location...
 131 LEGlyphFilter::~LEGlyphFilter()
 132 {
 133     // nothing to do
 134 }
 135 
 136 CharSubstitutionFilter::CharSubstitutionFilter(const LEFontInstance *fontInstance)
 137   : fFontInstance(fontInstance)
 138 {
 139     // nothing to do
 140 }
 141 
 142 CharSubstitutionFilter::~CharSubstitutionFilter()
 143 {
 144     // nothing to do
 145 }
 146 
 147 class CanonMarkFilter : public UMemory, public LEGlyphFilter
 148 {
 149 private:
 150   const LEReferenceTo<GlyphClassDefinitionTable> classDefTable;
 151 
 152     CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class
 153     CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class
 154 
 155 public:
 156     CanonMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success);
 157     virtual ~CanonMarkFilter();
 158 
 159     virtual le_bool accept(LEGlyphID glyph) const;
 160 };
 161 
 162 CanonMarkFilter::CanonMarkFilter(const LEReferenceTo<GlyphDefinitionTableHeader> &gdefTable, LEErrorCode &success)
 163   : classDefTable(gdefTable->getMarkAttachClassDefinitionTable(gdefTable, success))
 164 {
 165 }
 166 
 167 CanonMarkFilter::~CanonMarkFilter()
 168 {
 169     // nothing to do?
 170 }
 171 
 172 le_bool CanonMarkFilter::accept(LEGlyphID glyph) const
 173 {
 174   LEErrorCode success = LE_NO_ERROR;
 175   le_int32 glyphClass = classDefTable->getGlyphClass(classDefTable, glyph, success);
 176   if(LE_FAILURE(success)) return false;
 177   return glyphClass != 0;
 178 }
 179 
 180 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine)
 181 
 182 #define ccmpFeatureTag  LE_CCMP_FEATURE_TAG
 183 
 184 #define ccmpFeatureMask 0x80000000UL
 185 
 186 #define canonFeatures (ccmpFeatureMask)
 187 
 188 static const FeatureMap canonFeatureMap[] =
 189 {
 190     {ccmpFeatureTag, ccmpFeatureMask}
 191 };
 192 
 193 static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap);
 194 
 195 LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance,
 196                            le_int32 scriptCode,
 197                            le_int32 languageCode,
 198                            le_int32 typoFlags,
 199                            LEErrorCode &success)
 200   : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode),
 201     fTypoFlags(typoFlags), fFilterZeroWidth(TRUE)
 202 {
 203     if (LE_FAILURE(success)) {
 204         return;
 205     }
 206 
 207     fGlyphStorage = new LEGlyphStorage();
 208     if (fGlyphStorage == NULL) {
 209         success = LE_MEMORY_ALLOCATION_ERROR;
 210 }
 211 }
 212 
 213 le_int32 LayoutEngine::getGlyphCount() const
 214 {
 215     return fGlyphStorage->getGlyphCount();
 216 }
 217 
 218 void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
 219 {
 220     fGlyphStorage->getCharIndices(charIndices, indexBase, success);
 221 }
 222 
 223 void LayoutEngine::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const
 224 {
 225     fGlyphStorage->getCharIndices(charIndices, success);
 226 }
 227 
 228 // Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits
 229 void LayoutEngine::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const
 230 {
 231     fGlyphStorage->getGlyphs(glyphs, extraBits, success);
 232 }
 233 
 234 void LayoutEngine::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const
 235 {
 236     fGlyphStorage->getGlyphs(glyphs, success);
 237 }
 238 
 239 
 240 void LayoutEngine::getGlyphPositions(float positions[], LEErrorCode &success) const
 241 {
 242     fGlyphStorage->getGlyphPositions(positions, success);
 243 }
 244 
 245 void LayoutEngine::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const
 246 {
 247     fGlyphStorage->getGlyphPosition(glyphIndex, x, y, success);
 248 }
 249 
 250 le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 251                 LEUnicode *&outChars, LEGlyphStorage &glyphStorage, LEErrorCode &success)
 252 {
 253     if (LE_FAILURE(success)) {
 254         return 0;
 255     }
 256 
 257     if (offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 258         success = LE_ILLEGAL_ARGUMENT_ERROR;
 259         return 0;
 260     }
 261 
 262     if ((fTypoFlags & LE_NoCanon_FEATURE_FLAG) == 0) { // no canonical processing
 263       return count;
 264     }
 265 
 266     LEReferenceTo<GlyphSubstitutionTableHeader> canonGSUBTable((GlyphSubstitutionTableHeader *) CanonShaping::glyphSubstitutionTable);
 267     LETag scriptTag  = OpenTypeLayoutEngine::getScriptTag(fScriptCode);
 268     LETag langSysTag = OpenTypeLayoutEngine::getLangSysTag(fLanguageCode);
 269     le_int32 i, dir = 1, out = 0, outCharCount = count;
 270 
 271     if (canonGSUBTable->coversScript(canonGSUBTable,scriptTag, success) || LE_SUCCESS(success)) {
 272         CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance);
 273         if (substitutionFilter == NULL) {
 274             success = LE_MEMORY_ALLOCATION_ERROR;
 275             return 0;
 276         }
 277 
 278         const LEUnicode *inChars = &chars[offset];
 279         LEUnicode *reordered = NULL;
 280         LEGlyphStorage fakeGlyphStorage;
 281 
 282         fakeGlyphStorage.allocateGlyphArray(count, rightToLeft, success);
 283 
 284         if (LE_FAILURE(success)) {
 285             delete substitutionFilter;
 286             return 0;
 287         }
 288 
 289         // This is the cheapest way to get mark reordering only for Hebrew.
 290         // We could just do the mark reordering for all scripts, but most
 291         // of them probably don't need it...
 292         if (fScriptCode == hebrScriptCode) {
 293           reordered = LE_NEW_ARRAY(LEUnicode, count);
 294 
 295           if (reordered == NULL) {
 296             delete substitutionFilter;
 297             success = LE_MEMORY_ALLOCATION_ERROR;
 298             return 0;
 299           }
 300 
 301           CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, fakeGlyphStorage);
 302           inChars = reordered;
 303                 }
 304 
 305         fakeGlyphStorage.allocateAuxData(success);
 306 
 307         if (LE_FAILURE(success)) {
 308             delete substitutionFilter;
 309             return 0;
 310         }
 311 
 312         if (rightToLeft) {
 313             out = count - 1;
 314             dir = -1;
 315         }
 316 
 317         for (i = 0; i < count; i += 1, out += dir) {
 318             fakeGlyphStorage[out] = (LEGlyphID) inChars[i];
 319             fakeGlyphStorage.setAuxData(out, canonFeatures, success);
 320         }
 321 
 322         if (reordered != NULL) {
 323           LE_DELETE_ARRAY(reordered);
 324         }
 325 
 326         outCharCount = canonGSUBTable->process(canonGSUBTable, fakeGlyphStorage, rightToLeft, scriptTag, langSysTag, (const GlyphDefinitionTableHeader*)NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE, success);
 327 
 328         if (LE_FAILURE(success)) {
 329             delete substitutionFilter;
 330             return 0;
 331         }
 332 
 333         out = (rightToLeft? outCharCount - 1 : 0);
 334 
 335         /*
 336          * The char indices array in fakeGlyphStorage has the correct mapping
 337          * back to the original input characters. Save it in glyphStorage. The
 338          * subsequent call to glyphStoratge.allocateGlyphArray will keep this
 339          * array rather than allocating and initializing a new one.
 340          */
 341         glyphStorage.adoptCharIndicesArray(fakeGlyphStorage);
 342 
 343         outChars = LE_NEW_ARRAY(LEUnicode, outCharCount);
 344 
 345         if (outChars == NULL) {
 346             delete substitutionFilter;
 347             success = LE_MEMORY_ALLOCATION_ERROR;
 348             return 0;
 349         }
 350 
 351         for (i = 0; i < outCharCount; i += 1, out += dir) {
 352             outChars[out] = (LEUnicode) LE_GET_GLYPH(fakeGlyphStorage[i]);
 353         }
 354 
 355         delete substitutionFilter;
 356     }
 357 
 358     return outCharCount;
 359 }
 360 
 361 le_int32 LayoutEngine::computeGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 362                                             LEGlyphStorage &glyphStorage, LEErrorCode &success)
 363 {
 364     if (LE_FAILURE(success)) {
 365         return 0;
 366     }
 367 
 368     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 369         success = LE_ILLEGAL_ARGUMENT_ERROR;
 370         return 0;
 371     }
 372 
 373     LEUnicode *outChars = NULL;
 374     le_int32 outCharCount = characterProcessing(chars, offset, count, max, rightToLeft, outChars, glyphStorage, success);
 375 
 376     if (outChars != NULL) {
 377         mapCharsToGlyphs(outChars, 0, outCharCount, rightToLeft, rightToLeft, glyphStorage, success);
 378         LE_DELETE_ARRAY(outChars); // FIXME: a subclass may have allocated this, in which case this delete might not work...
 379     } else {
 380         mapCharsToGlyphs(chars, offset, count, rightToLeft, rightToLeft, glyphStorage, success);
 381     }
 382 
 383     return glyphStorage.getGlyphCount();
 384 }
 385 
 386 // Input: glyphs
 387 // Output: positions
 388 void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y, LEErrorCode &success)
 389 {
 390     if (LE_FAILURE(success)) {
 391         return;
 392     }
 393 
 394     glyphStorage.allocatePositions(success);
 395 
 396     if (LE_FAILURE(success)) {
 397         return;
 398     }
 399 
 400     le_int32 i, glyphCount = glyphStorage.getGlyphCount();
 401 
 402     for (i = 0; i < glyphCount; i += 1) {
 403         LEPoint advance;
 404 
 405         glyphStorage.setPosition(i, x, y, success);
 406 
 407         fFontInstance->getGlyphAdvance(glyphStorage[i], advance);
 408         x += advance.fX;
 409         y += advance.fY;
 410     }
 411 
 412     glyphStorage.setPosition(glyphCount, x, y, success);
 413 }
 414 
 415 void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse,
 416                                         LEGlyphStorage &glyphStorage, LEErrorCode &success)
 417 {
 418     if (LE_FAILURE(success)) {
 419         return;
 420     }
 421 
 422     if (chars == NULL || offset < 0 || count < 0) {
 423         success = LE_ILLEGAL_ARGUMENT_ERROR;
 424         return;
 425     }
 426 
 427     LEReferenceTo<GlyphDefinitionTableHeader> gdefTable((GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable,
 428                                                         CanonShaping::glyphDefinitionTableLen);
 429     CanonMarkFilter filter(gdefTable, success);
 430 
 431     adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success);
 432 
 433     if (fTypoFlags & LE_Kerning_FEATURE_FLAG) { /* kerning enabled */
 434       LETableReference kernTable(fFontInstance, LE_KERN_TABLE_TAG, success);
 435       KernTable kt(kernTable, success);
 436       kt.process(glyphStorage, success);
 437     }
 438 
 439     // default is no adjustments
 440     return;
 441 }
 442 
 443 void LayoutEngine::adjustMarkGlyphs(LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success)
 444 {
 445     float xAdjust = 0;
 446     le_int32 p, glyphCount = glyphStorage.getGlyphCount();
 447 
 448     if (LE_FAILURE(success)) {
 449         return;
 450     }
 451 
 452     if (markFilter == NULL) {
 453         success = LE_ILLEGAL_ARGUMENT_ERROR;
 454         return;
 455     }
 456 
 457     float ignore, prev;
 458 
 459     glyphStorage.getGlyphPosition(0, prev, ignore, success);
 460 
 461     for (p = 0; p < glyphCount; p += 1) {
 462         float next, xAdvance;
 463 
 464         glyphStorage.getGlyphPosition(p + 1, next, ignore, success);
 465 
 466         xAdvance = next - prev;
 467         glyphStorage.adjustPosition(p, xAdjust, 0, success);
 468 
 469         if (markFilter->accept(glyphStorage[p])) {
 470             xAdjust -= xAdvance;
 471         }
 472 
 473         prev = next;
 474     }
 475 
 476     glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success);
 477 }
 478 
 479 void LayoutEngine::adjustMarkGlyphs(const LEUnicode chars[], le_int32 charCount, le_bool reverse, LEGlyphStorage &glyphStorage, LEGlyphFilter *markFilter, LEErrorCode &success)
 480 {
 481     float xAdjust = 0;
 482     le_int32 c = 0, direction = 1, p;
 483     le_int32 glyphCount = glyphStorage.getGlyphCount();
 484 
 485     if (LE_FAILURE(success)) {
 486         return;
 487     }
 488 
 489     if (markFilter == NULL) {
 490         success = LE_ILLEGAL_ARGUMENT_ERROR;
 491         return;
 492     }
 493 
 494     if (reverse) {
 495         c = glyphCount - 1;
 496         direction = -1;
 497     }
 498 
 499     float ignore, prev;
 500 
 501     glyphStorage.getGlyphPosition(0, prev, ignore, success);
 502 
 503     for (p = 0; p < charCount; p += 1, c += direction) {
 504         float next, xAdvance;
 505 
 506         glyphStorage.getGlyphPosition(p + 1, next, ignore, success);
 507 
 508         xAdvance = next - prev;
 509         glyphStorage.adjustPosition(p, xAdjust, 0, success);
 510 
 511         if (markFilter->accept(chars[c])) {
 512             xAdjust -= xAdvance;
 513         }
 514 
 515         prev = next;
 516     }
 517 
 518     glyphStorage.adjustPosition(glyphCount, xAdjust, 0, success);
 519 }
 520 
 521 const void *LayoutEngine::getFontTable(LETag tableTag, size_t &length) const
 522 {
 523   return fFontInstance->getFontTable(tableTag, length);
 524 }
 525 
 526 void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool reverse, le_bool mirror,
 527                                     LEGlyphStorage &glyphStorage, LEErrorCode &success)
 528 {
 529     if (LE_FAILURE(success)) {
 530         return;
 531     }
 532 
 533     glyphStorage.allocateGlyphArray(count, reverse, success);
 534 
 535     DefaultCharMapper charMapper(TRUE, mirror);
 536 
 537     fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage);
 538 }
 539 
 540 // Input: characters, font?
 541 // Output: glyphs, positions, char indices
 542 // Returns: number of glyphs
 543 le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_int32 count, le_int32 max, le_bool rightToLeft,
 544                               float x, float y, LEErrorCode &success)
 545 {
 546     if (LE_FAILURE(success)) {
 547         return 0;
 548     }
 549 
 550     if (chars == NULL || offset < 0 || count < 0 || max < 0 || offset >= max || offset + count > max) {
 551         success = LE_ILLEGAL_ARGUMENT_ERROR;
 552         return 0;
 553     }
 554 
 555     le_int32 glyphCount;
 556 
 557     if (fGlyphStorage->getGlyphCount() > 0) {
 558         fGlyphStorage->reset();
 559     }
 560 
 561     glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success);
 562     positionGlyphs(*fGlyphStorage, x, y, success);
 563     adjustGlyphPositions(chars, offset, count, rightToLeft, *fGlyphStorage, success);
 564 
 565     return glyphCount;
 566 }
 567 
 568 void LayoutEngine::reset()
 569 {
 570   if(fGlyphStorage!=NULL) {
 571     fGlyphStorage->reset();

 572   }
 573 }
 574 
 575 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success)
 576 {
 577   //kerning and ligatures - by default
 578   return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, languageCode, LE_DEFAULT_FEATURE_FLAG, success);
 579 }
 580 
 581 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success)
 582 {
 583     static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG;
 584     static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG;
 585     static const le_uint32 morxTableTag = LE_MORX_TABLE_TAG;
 586 
 587     if (LE_FAILURE(success)) {
 588         return NULL;
 589     }
 590 
 591     LEReferenceTo<GlyphSubstitutionTableHeader> gsubTable(fontInstance,gsubTableTag,success);
 592     LayoutEngine *result = NULL;
 593     LETag scriptTag   = 0x00000000;
 594     LETag languageTag = 0x00000000;
 595     LETag v2ScriptTag = OpenTypeLayoutEngine::getV2ScriptTag(scriptCode);
 596 
 597     // Right now, only invoke V2 processing for Devanagari.  TODO: Allow more V2 scripts as they are
 598     // properly tested.
 599 
 600     if ( v2ScriptTag == dev2ScriptTag && gsubTable.isValid() && gsubTable->coversScript(gsubTable, v2ScriptTag, success )) {
 601       result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, TRUE, gsubTable, success);
 602     }
 603     else if (gsubTable.isValid() && gsubTable->coversScript(gsubTable, scriptTag = OpenTypeLayoutEngine::getScriptTag(scriptCode), success)) {
 604         switch (scriptCode) {
 605         case bengScriptCode:
 606         case devaScriptCode:
 607         case gujrScriptCode:
 608         case kndaScriptCode:
 609         case mlymScriptCode:
 610         case oryaScriptCode:
 611         case guruScriptCode:
 612         case tamlScriptCode:
 613         case teluScriptCode:
 614         case sinhScriptCode:
 615             result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, FALSE, gsubTable, success);
 616             break;
 617 
 618         case arabScriptCode:
 619             result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 620             break;
 621 
 622         case hebrScriptCode:
 623             // Disable hebrew ligatures since they have only archaic uses, see ticket #8318
 624             result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags & ~kTypoFlagLiga, gsubTable, success);
 625             break;
 626 
 627         case hangScriptCode:
 628             result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 629             break;
 630 
 631         case haniScriptCode:
 632             languageTag = OpenTypeLayoutEngine::getLangSysTag(languageCode);
 633 
 634             switch (languageCode) {
 635             case korLanguageCode:
 636             case janLanguageCode:
 637             case zhtLanguageCode:
 638             case zhsLanguageCode:
 639               if (gsubTable->coversScriptAndLanguage(gsubTable, scriptTag, languageTag, success, TRUE)) {
 640                     result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 641                     break;
 642               }
 643 
 644                 // note: falling through to default case.
 645             default:
 646                 result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 647                 break;
 648             }
 649 
 650             break;
 651 
 652         case tibtScriptCode:
 653             result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 654             break;
 655 
 656         case khmrScriptCode:
 657             result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 658             break;
 659 
 660         default:
 661             result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable, success);
 662             break;
 663         }
 664     } else {
 665         MorphTableHeader2 *morxTable = (MorphTableHeader2 *)fontInstance->getFontTable(morxTableTag);
 666         if (morxTable != NULL && SWAPL(morxTable->version)==0x00020000) {
 667             result = new GXLayoutEngine2(fontInstance, scriptCode, languageCode, morxTable, typoFlags, success);
 668         } else {
 669           LEReferenceTo<MorphTableHeader> mortTable(fontInstance, mortTableTag, success);
 670           if (LE_SUCCESS(success) && mortTable.isValid() && SWAPL(mortTable->version)==0x00010000) { // mort
 671             result = new GXLayoutEngine(fontInstance, scriptCode, languageCode, mortTable, success);
 672             } else {
 673                 switch (scriptCode) {
 674                     case bengScriptCode:
 675                     case devaScriptCode:
 676                     case gujrScriptCode:
 677                     case kndaScriptCode:
 678                     case mlymScriptCode:
 679                     case oryaScriptCode:
 680                     case guruScriptCode:
 681                     case tamlScriptCode:
 682                     case teluScriptCode:
 683                     case sinhScriptCode:
 684                     {
 685                         result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 686                         break;
 687                     }
 688 
 689             case arabScriptCode:
 690             //case hebrScriptCode:
 691                 result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 692                 break;
 693 
 694             //case hebrScriptCode:
 695             //    return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);
 696 
 697             case thaiScriptCode:
 698                 result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 699                 break;
 700 
 701             case hangScriptCode:
 702                 result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 703                 break;
 704 
 705                     default:
 706                         result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, success);
 707                         break;
 708                 }
 709             }
 710         }
 711     }
 712 
 713     if (result && LE_FAILURE(success)) {
 714                 delete result;
 715                 result = NULL;
 716         }
 717 
 718     if (result == NULL) {
 719         success = LE_MEMORY_ALLOCATION_ERROR;
 720     }
 721 
 722     return result;
 723 }
 724 
 725 LayoutEngine::~LayoutEngine() {
 726     delete fGlyphStorage;
 727 }
 728 
 729 U_NAMESPACE_END
--- EOF ---