ICU-400.39.tar.gz

[apple/icu.git] / icuSources / layout / LayoutEngine.cpp

diff --git a/icuSources/layout/LayoutEngine.cpp b/icuSources/layout/LayoutEngine.cpp
index 4a3d6bb0613706e3c9d19b9e448d381ab5f5f24f..019fbffbd8fd881ba56b859086d61e01b2ac0224 100644 (file)
--- a/icuSources/layout/LayoutEngine.cpp
+++ b/icuSources/layout/LayoutEngine.cpp
@@ -1,7 +1,7 @@
 
 /*
  *
 
 /*
  *

- * (C) Copyright IBM Corp. 1998-2004 - All Rights Reserved
+ * (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved

  *
  */
 
  *
  */
 


@@ -13,8 +13,11 @@
 #include "ArabicLayoutEngine.h"
 #include "CanonShaping.h"
 #include "HanLayoutEngine.h"
 #include "ArabicLayoutEngine.h"
 #include "CanonShaping.h"
 #include "HanLayoutEngine.h"

+#include "HangulLayoutEngine.h"

 #include "IndicLayoutEngine.h"
 #include "IndicLayoutEngine.h"

+#include "KhmerLayoutEngine.h"

 #include "ThaiLayoutEngine.h"
 #include "ThaiLayoutEngine.h"

+#include "TibetanLayoutEngine.h"

 #include "GXLayoutEngine.h"
 #include "ScriptAndLanguageTags.h"
 #include "CharSubstitutionFilter.h"
 #include "GXLayoutEngine.h"
 #include "ScriptAndLanguageTags.h"
 #include "CharSubstitutionFilter.h"


@@ -23,13 +26,17 @@
 
 #include "OpenTypeUtilities.h"
 #include "GlyphSubstitutionTables.h"
 
 #include "OpenTypeUtilities.h"
 #include "GlyphSubstitutionTables.h"

+#include "GlyphDefinitionTables.h"

 #include "MorphTables.h"
 
 #include "DefaultCharMapper.h"
 
 #include "MorphTables.h"
 
 #include "DefaultCharMapper.h"
 

+#include "KernTable.h"
+

 U_NAMESPACE_BEGIN
 
 U_NAMESPACE_BEGIN
 

-#define ARRAY_SIZE(array) (sizeof array  / sizeof array[0])
+/* Leave this copyright notice here! It needs to go somewhere in this library. */
+static const char copyright[] = U_COPYRIGHT_STRING;

 
 const LEUnicode32 DefaultCharMapper::controlChars[] = {
     0x0009, 0x000A, 0x000D,
 
 const LEUnicode32 DefaultCharMapper::controlChars[] = {
     0x0009, 0x000A, 0x000D,


@@ -38,29 +45,7 @@ const LEUnicode32 DefaultCharMapper::controlChars[] = {
     0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F
 };
 
     0x206A, 0x206B, 0x206C, 0x206D, 0x206E, 0x206F
 };
 

-const le_int32 DefaultCharMapper::controlCharsCount = ARRAY_SIZE(controlChars);
-
-const LEUnicode32 DefaultCharMapper::mirroredChars[] = {
-    0x0028, 0x0029, // ascii paired punctuation
-    0x003c, 0x003e,
-    0x005b, 0x005d,
-    0x007b, 0x007d,
-    0x2045, 0x2046, // math symbols (not complete)
-    0x207d, 0x207e,
-    0x208d, 0x208e,
-    0x2264, 0x2265,
-    0x3008, 0x3009, // chinese paired punctuation
-    0x300a, 0x300b,
-    0x300c, 0x300d,
-    0x300e, 0x300f,
-    0x3010, 0x3011,
-    0x3014, 0x3015,
-    0x3016, 0x3017,
-    0x3018, 0x3019,
-    0x301a, 0x301b
-};
-
-const le_int32 DefaultCharMapper::mirroredCharsCount = ARRAY_SIZE(mirroredChars);
+const le_int32 DefaultCharMapper::controlCharsCount = LE_ARRAY_SIZE(controlChars);

 
 LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
 {
 
 LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
 {


@@ -73,12 +58,10 @@ LEUnicode32 DefaultCharMapper::mapChar(LEUnicode32 ch) const
     }
 
     if (fMirror) {
     }
 
     if (fMirror) {

-        le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)mirroredChars, mirroredCharsCount);
+        le_int32 index = OpenTypeUtilities::search((le_uint32) ch, (le_uint32 *)DefaultCharMapper::mirroredChars, DefaultCharMapper::mirroredCharsCount);

 
         if (mirroredChars[index] == ch) {
 
         if (mirroredChars[index] == ch) {

-            le_int32 mirrorOffset = ((index & 1) == 0) ? 1 : -1;
-
-            return mirroredChars[index + mirrorOffset];
+            return DefaultCharMapper::srahCderorrim[index];

         }
     }
 
         }
     }
 


@@ -104,17 +87,56 @@ CharSubstitutionFilter::~CharSubstitutionFilter()
     // nothing to do
 }
 
     // nothing to do
 }
 

+class CanonMarkFilter : public UMemory, public LEGlyphFilter
+{
+private:
+    const GlyphClassDefinitionTable *classDefTable;
+
+    CanonMarkFilter(const CanonMarkFilter &other); // forbid copying of this class
+    CanonMarkFilter &operator=(const CanonMarkFilter &other); // forbid copying of this class
+
+public:
+    CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable);
+    virtual ~CanonMarkFilter();
+
+    virtual le_bool accept(LEGlyphID glyph) const;
+};
+
+CanonMarkFilter::CanonMarkFilter(const GlyphDefinitionTableHeader *gdefTable)
+{
+    classDefTable = gdefTable->getMarkAttachClassDefinitionTable();
+}
+
+CanonMarkFilter::~CanonMarkFilter()
+{
+    // nothing to do?
+}
+
+le_bool CanonMarkFilter::accept(LEGlyphID glyph) const
+{
+    le_int32 glyphClass = classDefTable->getGlyphClass(glyph);
+
+    return glyphClass != 0;
+}

 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine)
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LayoutEngine)
 

-static const LETag emptyTag = 0x00000000;
+#define ccmpFeatureTag  LE_CCMP_FEATURE_TAG

 
 

-static const LETag ccmpFeatureTag = LE_CCMP_FEATURE_TAG;
+#define ccmpFeatureMask 0x80000000UL

 
 

-static const LETag canonFeatures[] = {ccmpFeatureTag, emptyTag};
+#define canonFeatures (ccmpFeatureMask)

 
 

-LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode)
-    : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode)
+static const FeatureMap canonFeatureMap[] =
+{
+    {ccmpFeatureTag, ccmpFeatureMask}
+};
+
+static const le_int32 canonFeatureMapCount = LE_ARRAY_SIZE(canonFeatureMap);
+
+LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags)
+  : fGlyphStorage(NULL), fFontInstance(fontInstance), fScriptCode(scriptCode), fLanguageCode(languageCode),
+    fTypoFlags(typoFlags), fFilterZeroWidth(TRUE)

 {
     fGlyphStorage = new LEGlyphStorage();
 }
 {
     fGlyphStorage = new LEGlyphStorage();
 }


@@ -122,7 +144,7 @@ LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCo
 le_int32 LayoutEngine::getGlyphCount() const
 {
     return fGlyphStorage->getGlyphCount();
 le_int32 LayoutEngine::getGlyphCount() const
 {
     return fGlyphStorage->getGlyphCount();

-};
+}

 
 void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
 {
 
 void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
 {


@@ -175,9 +197,32 @@ le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 off
 
     if (canonGSUBTable->coversScript(scriptTag)) {
         CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance);
 
     if (canonGSUBTable->coversScript(scriptTag)) {
         CharSubstitutionFilter *substitutionFilter = new CharSubstitutionFilter(fFontInstance);

+               const LEUnicode *inChars = &chars[offset];
+               LEUnicode *reordered = NULL;
+        LEGlyphStorage fakeGlyphStorage;
+
+        fakeGlyphStorage.allocateGlyphArray(count, rightToLeft, success);
+
+        if (LE_FAILURE(success)) {
+            return 0;
+        }
+
+               // This is the cheapest way to get mark reordering only for Hebrew.
+               // We could just do the mark reordering for all scripts, but most
+               // of them probably don't need it...
+               if (fScriptCode == hebrScriptCode) {
+                       reordered = LE_NEW_ARRAY(LEUnicode, count);
+
+                       if (reordered == NULL) {
+                               success = LE_MEMORY_ALLOCATION_ERROR;
+                               return 0;
+                       }
+
+                       CanonShaping::reorderMarks(&chars[offset], count, rightToLeft, reordered, fakeGlyphStorage);
+                       inChars = reordered;
+        }

 
 

-        glyphStorage.allocateGlyphArray(count, rightToLeft, success);
-        glyphStorage.allocateAuxData(success);
+        fakeGlyphStorage.allocateAuxData(success);

 
         if (LE_FAILURE(success)) {
             return 0;
 
         if (LE_FAILURE(success)) {
             return 0;


@@ -189,17 +234,29 @@ le_int32 LayoutEngine::characterProcessing(const LEUnicode chars[], le_int32 off
         }
 
         for (i = 0; i < count; i += 1, out += dir) {
         }
 
         for (i = 0; i < count; i += 1, out += dir) {

-            glyphStorage[out] = (LEGlyphID) chars[offset + i];
-            glyphStorage.setAuxData(out, (void *) canonFeatures, success);
+            fakeGlyphStorage[out] = (LEGlyphID) inChars[i];
+            fakeGlyphStorage.setAuxData(out, canonFeatures, success);

         }
 
         }
 

-        outCharCount = canonGSUBTable->process(glyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, NULL);
+               if (reordered != NULL) {
+                       LE_DELETE_ARRAY(reordered);
+               }

 
 

-        out = (rightToLeft? count - 1 : 0);
+        outCharCount = canonGSUBTable->process(fakeGlyphStorage, rightToLeft, scriptTag, langSysTag, NULL, substitutionFilter, canonFeatureMap, canonFeatureMapCount, FALSE);
+
+        out = (rightToLeft? outCharCount - 1 : 0);
+
+        /*
+         * The char indices array in fakeGlyphStorage has the correct mapping
+         * back to the original input characters. Save it in glyphStorage. The
+         * subsequent call to glyphStoratge.allocateGlyphArray will keep this
+         * array rather than allocating and initializing a new one.
+         */
+        glyphStorage.adoptCharIndicesArray(fakeGlyphStorage);

 
         outChars = LE_NEW_ARRAY(LEUnicode, outCharCount);
         for (i = 0; i < outCharCount; i += 1, out += dir) {
 
         outChars = LE_NEW_ARRAY(LEUnicode, outCharCount);
         for (i = 0; i < outCharCount; i += 1, out += dir) {

-            outChars[out] = (LEUnicode) LE_GET_GLYPH(glyphStorage[i]);
+            outChars[out] = (LEUnicode) LE_GET_GLYPH(fakeGlyphStorage[i]);

         }
 
         delete substitutionFilter;
         }
 
         delete substitutionFilter;


@@ -262,8 +319,8 @@ void LayoutEngine::positionGlyphs(LEGlyphStorage &glyphStorage, float x, float y
     glyphStorage.setPosition(glyphCount, x, y, success);
 }
 
     glyphStorage.setPosition(glyphCount, x, y, success);
 }
 

-void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool /*reverse*/,
-                                        LEGlyphStorage &/*glyphStorage*/, LEErrorCode &success)
+void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset, le_int32 count, le_bool  reverse,
+                                        LEGlyphStorage &glyphStorage, LEErrorCode &success)

 {
     if (LE_FAILURE(success)) {
         return;
 {
     if (LE_FAILURE(success)) {
         return;


@@ -274,6 +331,18 @@ void LayoutEngine::adjustGlyphPositions(const LEUnicode chars[], le_int32 offset
         return;
     }
 
         return;
     }
 

+    GlyphDefinitionTableHeader *gdefTable = (GlyphDefinitionTableHeader *) CanonShaping::glyphDefinitionTable;
+    CanonMarkFilter filter(gdefTable);
+
+    adjustMarkGlyphs(&chars[offset], count, reverse, glyphStorage, &filter, success);
+
+    if (fTypoFlags & 0x1) { /* kerning enabled */
+      static const le_uint32 kernTableTag = LE_KERN_TABLE_TAG;
+
+      KernTable kt(fFontInstance, getFontTable(kernTableTag));
+      kt.process(glyphStorage);
+    }
+

     // default is no adjustments
     return;
 }
     // default is no adjustments
     return;
 }


@@ -372,7 +441,7 @@ void LayoutEngine::mapCharsToGlyphs(const LEUnicode chars[], le_int32 offset, le
 
     DefaultCharMapper charMapper(TRUE, mirror);
 
 
     DefaultCharMapper charMapper(TRUE, mirror);
 

-    fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, glyphStorage);
+    fFontInstance->mapCharsToGlyphs(chars, offset, count, reverse, &charMapper, fFilterZeroWidth, glyphStorage);

 }
 
 // Input: characters, font?
 }
 
 // Input: characters, font?


@@ -391,6 +460,10 @@ le_int32 LayoutEngine::layoutChars(const LEUnicode chars[], le_int32 offset, le_
     }
 
     le_int32 glyphCount;
     }
 
     le_int32 glyphCount;

+
+    if (fGlyphStorage->getGlyphCount() > 0) {
+        fGlyphStorage->reset();
+    }

     
     glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success);
     positionGlyphs(*fGlyphStorage, x, y, success);
     
     glyphCount = computeGlyphs(chars, offset, count, max, rightToLeft, *fGlyphStorage, success);
     positionGlyphs(*fGlyphStorage, x, y, success);


@@ -405,6 +478,12 @@ void LayoutEngine::reset()
 }
     
 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success)
 }
     
 LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, LEErrorCode &success)

+{
+  // 3 -> kerning and ligatures
+  return LayoutEngine::layoutEngineFactory(fontInstance, scriptCode, languageCode, 3, success);
+}
+    
+LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstance, le_int32 scriptCode, le_int32 languageCode, le_int32 typoFlags, LEErrorCode &success)

 {
     static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG;
     static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG;
 {
     static const le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG;
     static const le_uint32 mortTableTag = LE_MORT_TABLE_TAG;


@@ -429,11 +508,16 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
         case guruScriptCode:
         case tamlScriptCode:
         case teluScriptCode:
         case guruScriptCode:
         case tamlScriptCode:
         case teluScriptCode:

-            result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, gsubTable);
+        case sinhScriptCode:
+            result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);

             break;
 
         case arabScriptCode:
             break;
 
         case arabScriptCode:

-            result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, gsubTable);
+            result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);
+            break;
+
+        case hangScriptCode:
+            result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);

             break;
 
         case haniScriptCode:
             break;
 
         case haniScriptCode:


@@ -445,20 +529,28 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
             case zhtLanguageCode:
             case zhsLanguageCode:
                 if (gsubTable->coversScriptAndLanguage(scriptTag, languageTag, TRUE)) {
             case zhtLanguageCode:
             case zhsLanguageCode:
                 if (gsubTable->coversScriptAndLanguage(scriptTag, languageTag, TRUE)) {

-                    result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, gsubTable);
+                    result = new HanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);

                     break;
                 }
 
                 // note: falling through to default case.
             default:
                     break;
                 }
 
                 // note: falling through to default case.
             default:

-                result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, gsubTable);
+                result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);

                 break;
             }
 
             break;
 
                 break;
             }
 
             break;
 

+        case tibtScriptCode:
+            result = new TibetanOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);
+            break;
+
+        case khmrScriptCode:
+            result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);
+            break;
+

         default:
         default:

-            result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, gsubTable);
+            result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable);

             break;
         }
     } else {
             break;
         }
     } else {


@@ -477,25 +569,30 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
             case guruScriptCode:
             case tamlScriptCode:
             case teluScriptCode:
             case guruScriptCode:
             case tamlScriptCode:
             case teluScriptCode:

+            case sinhScriptCode:

             {
             {

-                result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode);
+                result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);

                 break;
             }
 
             case arabScriptCode:
             //case hebrScriptCode:
                 break;
             }
 
             case arabScriptCode:
             //case hebrScriptCode:

-                result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode);
+                result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);

                 break;
 
             //case hebrScriptCode:
                 break;
 
             //case hebrScriptCode:

-            //    return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode);
+            //    return new HebrewOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);

 
             case thaiScriptCode:
 
             case thaiScriptCode:

-                result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode);
+                result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);
+                break;
+
+            case hangScriptCode:
+                result = new HangulOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);

                 break;
 
             default:
                 break;
 
             default:

-                result = new LayoutEngine(fontInstance, scriptCode, languageCode);
+                result = new LayoutEngine(fontInstance, scriptCode, languageCode, typoFlags);

                 break;
             }
         }
                 break;
             }
         }


@@ -509,7 +606,7 @@ LayoutEngine *LayoutEngine::layoutEngineFactory(const LEFontInstance *fontInstan
 }
 
 LayoutEngine::~LayoutEngine() {
 }
 
 LayoutEngine::~LayoutEngine() {

-    reset();
+    delete fGlyphStorage;

 }
 
 U_NAMESPACE_END
 }
 
 U_NAMESPACE_END