ICU-6.2.10.tar.gz

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

diff --git a/icuSources/layout/GlyphIterator.cpp b/icuSources/layout/GlyphIterator.cpp
index b612e58e6a67a23dbc34af1b6e23f51c168a1c4c..20bcc8600e405af1d29c6d38b1cd7e1027f1df94 100644 (file)
--- a/icuSources/layout/GlyphIterator.cpp
+++ b/icuSources/layout/GlyphIterator.cpp
@@ -1,7 +1,6 @@
 /*
 /*

- * %W% %E%

  *
  *

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

  *
  */
 
  *
  */
 


@@ -10,36 +9,40 @@
 #include "GlyphDefinitionTables.h"
 #include "GlyphPositionAdjustments.h"
 #include "GlyphIterator.h"
 #include "GlyphDefinitionTables.h"
 #include "GlyphPositionAdjustments.h"
 #include "GlyphIterator.h"

+#include "LEGlyphStorage.h"

 #include "Lookups.h"
 #include "LESwaps.h"
 
 U_NAMESPACE_BEGIN
 
 #include "Lookups.h"
 #include "LESwaps.h"
 
 U_NAMESPACE_BEGIN
 

-GlyphIterator::GlyphIterator(LEGlyphID *theGlyphs, GlyphPositionAdjustment *theGlyphPositionAdjustments, le_int32 theGlyphCount,
-    le_bool rightToLeft, le_uint16 theLookupFlags, LETag theFeatureTag, const LETag *theGlyphTags[],
+GlyphIterator::GlyphIterator(LEGlyphStorage &theGlyphStorage, GlyphPositionAdjustment *theGlyphPositionAdjustments, le_bool rightToLeft, le_uint16 theLookupFlags, LETag theFeatureTag,

     const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader)
     const GlyphDefinitionTableHeader *theGlyphDefinitionTableHeader)

-  : direction(1), position(-1), nextLimit(theGlyphCount), prevLimit(-1),
+  : direction(1), position(-1), nextLimit(-1), prevLimit(-1),

     cursiveFirstPosition(-1), cursiveLastPosition(-1), cursiveBaselineAdjustment(0),
     cursiveFirstPosition(-1), cursiveLastPosition(-1), cursiveBaselineAdjustment(0),

-    glyphs(theGlyphs), glyphPositionAdjustments(theGlyphPositionAdjustments), lookupFlags(theLookupFlags),
-    featureTag(theFeatureTag), glyphTags(theGlyphTags),
-    glyphClassDefinitionTable(NULL),
-    markAttachClassDefinitionTable(NULL)
+    glyphStorage(theGlyphStorage), glyphPositionAdjustments(theGlyphPositionAdjustments),
+    srcIndex(-1), destIndex(-1), lookupFlags(theLookupFlags), featureTag(theFeatureTag),
+    glyphClassDefinitionTable(NULL), markAttachClassDefinitionTable(NULL)

 
 {
 
 {

+    le_int32 glyphCount = glyphStorage.getGlyphCount();
+

     if (theGlyphDefinitionTableHeader != NULL) {
         glyphClassDefinitionTable = theGlyphDefinitionTableHeader->getGlyphClassDefinitionTable();
         markAttachClassDefinitionTable = theGlyphDefinitionTableHeader->getMarkAttachClassDefinitionTable();
     }
 
     if (theGlyphDefinitionTableHeader != NULL) {
         glyphClassDefinitionTable = theGlyphDefinitionTableHeader->getGlyphClassDefinitionTable();
         markAttachClassDefinitionTable = theGlyphDefinitionTableHeader->getMarkAttachClassDefinitionTable();
     }
 

+    nextLimit = glyphCount;
+

     if (rightToLeft) {
         direction = -1;
     if (rightToLeft) {
         direction = -1;

-        position = theGlyphCount;
+        position = glyphCount;

         nextLimit = -1;
         nextLimit = -1;

-        prevLimit = theGlyphCount;
+        prevLimit = glyphCount;

     }
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that)
     }
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that)

+  : glyphStorage(that.glyphStorage)

 {
     direction    = that.direction;
     position     = that.position;
 {
     direction    = that.direction;
     position     = that.position;


@@ -49,16 +52,17 @@ GlyphIterator::GlyphIterator(GlyphIterator &that)
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 

-    glyphs = that.glyphs;

     glyphPositionAdjustments = that.glyphPositionAdjustments;
     glyphPositionAdjustments = that.glyphPositionAdjustments;

+    srcIndex = that.srcIndex;
+    destIndex = that.destIndex;

     lookupFlags = that.lookupFlags;
     featureTag = that.featureTag;
     lookupFlags = that.lookupFlags;
     featureTag = that.featureTag;

-    glyphTags = that.glyphTags;

     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that, LETag newFeatureTag)
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that, LETag newFeatureTag)

+  : glyphStorage(that.glyphStorage)

 {
     direction    = that.direction;
     position     = that.position;
 {
     direction    = that.direction;
     position     = that.position;


@@ -68,16 +72,17 @@ GlyphIterator::GlyphIterator(GlyphIterator &that, LETag newFeatureTag)
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 

-    glyphs = that.glyphs;

     glyphPositionAdjustments = that.glyphPositionAdjustments;
     glyphPositionAdjustments = that.glyphPositionAdjustments;

+    srcIndex = that.srcIndex;
+    destIndex = that.destIndex;

     lookupFlags = that.lookupFlags;
     featureTag = newFeatureTag;
     lookupFlags = that.lookupFlags;
     featureTag = newFeatureTag;

-    glyphTags = that.glyphTags;

     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that, le_uint16 newLookupFlags)
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 
 GlyphIterator::GlyphIterator(GlyphIterator &that, le_uint16 newLookupFlags)

+  : glyphStorage(that.glyphStorage)

 {
     direction    = that.direction;
     position     = that.position;
 {
     direction    = that.direction;
     position     = that.position;


@@ -88,21 +93,43 @@ GlyphIterator::GlyphIterator(GlyphIterator &that, le_uint16 newLookupFlags)
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 
     cursiveFirstPosition = that.cursiveFirstPosition;
     cursiveLastPosition  = that.cursiveLastPosition;
 

-    glyphs = that.glyphs;

     glyphPositionAdjustments = that.glyphPositionAdjustments;
     glyphPositionAdjustments = that.glyphPositionAdjustments;

+    srcIndex = that.srcIndex;
+    destIndex = that.destIndex;

     lookupFlags = newLookupFlags;
     featureTag = that.featureTag;
     lookupFlags = newLookupFlags;
     featureTag = that.featureTag;

-    glyphTags = that.glyphTags;

     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 
     glyphClassDefinitionTable = that.glyphClassDefinitionTable;
     markAttachClassDefinitionTable = that.markAttachClassDefinitionTable;
 }
 

-GlyphIterator::GlyphIterator()
+GlyphIterator::~GlyphIterator()

 {
 {

-};
+    // nothing to do, right?
+}

 
 

-GlyphIterator::~GlyphIterator()
+void GlyphIterator::reset(le_uint16 newLookupFlags, LETag newFeatureTag)
+{
+    position    = prevLimit;
+    featureTag  = newFeatureTag;
+    lookupFlags = newLookupFlags;
+}
+
+LEGlyphID *GlyphIterator::insertGlyphs(le_int32 count)
+{
+    return glyphStorage.insertGlyphs(position, count);
+}
+
+le_int32 GlyphIterator::applyInsertions()

 {
 {

+    le_int32 newGlyphCount = glyphStorage.applyInsertions();
+
+    if (direction < 0) {
+        prevLimit = newGlyphCount;
+    } else {
+        nextLimit = newGlyphCount;
+    }
+
+    return newGlyphCount;

 }
 
 le_int32 GlyphIterator::getCurrStreamPosition() const
 }
 
 le_int32 GlyphIterator::getCurrStreamPosition() const


@@ -147,7 +174,7 @@ LEGlyphID GlyphIterator::getCurrGlyphID() const
         }
     }
 
         }
     }
 

-    return glyphs[position];
+    return glyphStorage[position];

 }
 
 LEGlyphID GlyphIterator::getCursiveLastGlyphID() const
 }
 
 LEGlyphID GlyphIterator::getCursiveLastGlyphID() const


@@ -162,7 +189,7 @@ LEGlyphID GlyphIterator::getCursiveLastGlyphID() const
         }
     }
 
         }
     }
 

-    return glyphs[cursiveLastPosition];
+    return glyphStorage[cursiveLastPosition];

 }
 
 void GlyphIterator::getCursiveLastExitPoint(LEPoint &exitPoint) const
 }
 
 void GlyphIterator::getCursiveLastExitPoint(LEPoint &exitPoint) const


@@ -213,7 +240,9 @@ void GlyphIterator::getCursiveLastPositionAdjustment(GlyphPositionAdjustment &ad
 
 void GlyphIterator::setCurrGlyphID(TTGlyphID glyphID)
 {
 
 void GlyphIterator::setCurrGlyphID(TTGlyphID glyphID)
 {

-    glyphs[position] = LE_SET_GLYPH(glyphs[position], glyphID);
+    LEGlyphID glyph = glyphStorage[position];
+
+    glyphStorage[position] = LE_SET_GLYPH(glyph, glyphID);

 }
 
 void GlyphIterator::setCurrStreamPosition(le_int32 newPosition)
 }
 
 void GlyphIterator::setCurrStreamPosition(le_int32 newPosition)


@@ -297,6 +326,25 @@ void GlyphIterator::adjustCurrGlyphPositionAdjustment(float xPlacementAdjust, fl
     glyphPositionAdjustments[position].adjustYAdvance(yAdvanceAdjust);
 }
 
     glyphPositionAdjustments[position].adjustYAdvance(yAdvanceAdjust);
 }
 

+void GlyphIterator::setCurrGlyphPositionAdjustment(float xPlacementAdjust, float yPlacementAdjust,
+                                                      float xAdvanceAdjust, float yAdvanceAdjust)
+{
+    if (direction < 0) {
+        if (position <= nextLimit || position >= prevLimit) {
+            return;
+        }
+    } else {
+        if (position <= prevLimit || position >= nextLimit) {
+            return;
+        }
+    }
+
+    glyphPositionAdjustments[position].setXPlacement(xPlacementAdjust);
+    glyphPositionAdjustments[position].setYPlacement(yPlacementAdjust);
+    glyphPositionAdjustments[position].setXAdvance(xAdvanceAdjust);
+    glyphPositionAdjustments[position].setYAdvance(yAdvanceAdjust);
+}
+

 void GlyphIterator::setCursiveFirstExitPoint()
 {
     if (direction < 0) {
 void GlyphIterator::setCursiveFirstExitPoint()
 {
     if (direction < 0) {


@@ -376,11 +424,11 @@ void GlyphIterator::adjustCursiveLastGlyphPositionAdjustment(float xPlacementAdj
 
 le_bool GlyphIterator::filterGlyph(le_uint32 index) const
 {
 
 le_bool GlyphIterator::filterGlyph(le_uint32 index) const
 {

-    LEGlyphID glyphID = glyphs[index];
+    LEGlyphID glyphID = glyphStorage[index];

     le_int32 glyphClass = gcdNoGlyphClass;
 
     if (LE_GET_GLYPH(glyphID) >= 0xFFFE) {
     le_int32 glyphClass = gcdNoGlyphClass;
 
     if (LE_GET_GLYPH(glyphID) >= 0xFFFE) {

-        return true;
+        return TRUE;

     }
 
     if (glyphClassDefinitionTable != NULL) {
     }
 
     if (glyphClassDefinitionTable != NULL) {


@@ -390,7 +438,7 @@ le_bool GlyphIterator::filterGlyph(le_uint32 index) const
     switch (glyphClass)
     {
     case gcdNoGlyphClass:
     switch (glyphClass)
     {
     case gcdNoGlyphClass:

-        return false;
+        return FALSE;

 
     case gcdSimpleGlyph:
         return (lookupFlags & lfIgnoreBaseGlyphs) != 0;
 
     case gcdSimpleGlyph:
         return (lookupFlags & lfIgnoreBaseGlyphs) != 0;


@@ -401,7 +449,7 @@ le_bool GlyphIterator::filterGlyph(le_uint32 index) const
     case gcdMarkGlyph:
     {
         if ((lookupFlags & lfIgnoreMarks) != 0) {
     case gcdMarkGlyph:
     {
         if ((lookupFlags & lfIgnoreMarks) != 0) {

-            return true;
+            return TRUE;

         }
 
         le_uint16 markAttachType = (lookupFlags & lfMarkAttachTypeMask) >> lfMarkAttachTypeShift;
         }
 
         le_uint16 markAttachType = (lookupFlags & lfMarkAttachTypeMask) >> lfMarkAttachTypeShift;


@@ -410,37 +458,38 @@ le_bool GlyphIterator::filterGlyph(le_uint32 index) const
             return markAttachClassDefinitionTable->getGlyphClass(glyphID) != markAttachType;
         }
 
             return markAttachClassDefinitionTable->getGlyphClass(glyphID) != markAttachType;
         }
 

-        return false;
+        return FALSE;

     }
 
     case gcdComponentGlyph:
         return (lookupFlags & lfIgnoreBaseGlyphs) != 0;
 
     default:
     }
 
     case gcdComponentGlyph:
         return (lookupFlags & lfIgnoreBaseGlyphs) != 0;
 
     default:

-        return false;
+        return FALSE;

     }
 }
 
     }
 }
 

-const LETag emptyTag = 0;
-const LETag defaultTag = 0xFFFFFFFF;
+static const LETag emptyTag = 0;
+static const LETag defaultTag = 0xFFFFFFFF;

 
 le_bool GlyphIterator::hasFeatureTag() const
 {
     if (featureTag == defaultTag || featureTag == emptyTag) {
 
 le_bool GlyphIterator::hasFeatureTag() const
 {
     if (featureTag == defaultTag || featureTag == emptyTag) {

-        return true;
+        return TRUE;

     }
 
     }
 

-    if (glyphTags != NULL) {
-        const LETag *tagList = glyphTags[position];
+    LEErrorCode success = LE_NO_ERROR;
+    const LETag *tagList = (const LETag *) glyphStorage.getAuxData(position, success);

 
 

+    if (tagList != NULL) {

         for (le_int32 tag = 0; tagList[tag] != emptyTag; tag += 1) {
             if (tagList[tag] == featureTag) {
         for (le_int32 tag = 0; tagList[tag] != emptyTag; tag += 1) {
             if (tagList[tag] == featureTag) {

-                return true;
+                return TRUE;

             }
         }
     }
 
             }
         }
     }
 

-    return false;
+    return FALSE;

 }
 
 le_bool GlyphIterator::findFeatureTag()
 }
 
 le_bool GlyphIterator::findFeatureTag()


@@ -448,11 +497,11 @@ le_bool GlyphIterator::findFeatureTag()
     while (nextInternal()) {
         if (hasFeatureTag()) {
             prevInternal();
     while (nextInternal()) {
         if (hasFeatureTag()) {
             prevInternal();

-            return true;
+            return TRUE;

         }
     }
 
         }
     }
 

-    return false;
+    return FALSE;

 }
 
 
 }
 
 


@@ -506,7 +555,7 @@ le_int32 GlyphIterator::getMarkComponent(le_int32 markPosition) const
     le_int32 posn;
 
     for (posn = position; posn != markPosition; posn += direction) {
     le_int32 posn;
 
     for (posn = position; posn != markPosition; posn += direction) {

-        if (glyphs[posn] == 0xFFFE) {
+        if (glyphStorage[posn] == 0xFFFE) {

             component += 1;
         }
     }
             component += 1;
         }
     }


@@ -523,7 +572,7 @@ le_bool GlyphIterator::findMark2Glyph()
 
     do {
         newPosition -= direction;
 
     do {
         newPosition -= direction;

-    } while (newPosition != prevLimit && glyphs[newPosition] != 0xFFFE && filterGlyph(newPosition));
+    } while (newPosition != prevLimit && glyphStorage[newPosition] != 0xFFFE && filterGlyph(newPosition));

 
     position = newPosition;
 
 
     position = newPosition;