/*

  **********************************************************************

  *   Copyright (C) 1998-2004, International Business Machines

  *   Corporation and others.  All Rights Reserved.

  **********************************************************************

  */

 #include "LETypes.h"

 #include "LEInsertionList.h"

 #include "LEGlyphStorage.h"

 U_NAMESPACE_BEGIN

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEGlyphStorage)

 LEGlyphStorage::LEGlyphStorage()

     : fGlyphCount(0), fGlyphs(NULL), fCharIndices(NULL), fPositions(NULL),

       fAuxData(NULL), fInsertionList(NULL), fSrcIndex(0), fDestIndex(0)

 {

     // nothing else to do!

 }

 LEGlyphStorage::~LEGlyphStorage()

 {

     reset();

 }

 void LEGlyphStorage::reset()

 {

     fGlyphCount = 0;

     if (fPositions != NULL) {

         LE_DELETE_ARRAY(fPositions);

         fPositions = NULL;

     }

     if (fAuxData != NULL) {

         LE_DELETE_ARRAY(fAuxData);

         fAuxData = NULL;

     }

     if (fInsertionList != NULL) {

         delete fInsertionList;

         fInsertionList = NULL;

     }

     if (fCharIndices != NULL) {

         LE_DELETE_ARRAY(fCharIndices);

         fCharIndices = NULL;

     }

     if (fGlyphs != NULL) {

         LE_DELETE_ARRAY(fGlyphs);

         fGlyphs = NULL;

     }

 }

 // FIXME: This might get called more than once, for various reasons. Is

 // testing for pre-existing glyph and charIndices arrays good enough?

 void LEGlyphStorage::allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (initialGlyphCount <= 0) {

         success = LE_ILLEGAL_ARGUMENT_ERROR;

         return;

     }

     if (fGlyphs == NULL) {

         fGlyphCount = initialGlyphCount;

         fGlyphs = LE_NEW_ARRAY(LEGlyphID, fGlyphCount);

         if (fGlyphs == NULL) {

             success = LE_MEMORY_ALLOCATION_ERROR;

             return;

         }

     }

     if (fCharIndices == NULL) {

         fCharIndices = LE_NEW_ARRAY(le_int32, fGlyphCount);

         if (fCharIndices == NULL) {

             LE_DELETE_ARRAY(fGlyphs);

             fGlyphs = NULL;

             success = LE_MEMORY_ALLOCATION_ERROR;

             return;

         }

         // Initialize the charIndices array

         le_int32 i, count = fGlyphCount, dir = 1, out = 0;

         if (rightToLeft) {

             out = fGlyphCount - 1;

             dir = -1;

         }

         for (i = 0; i < count; i += 1, out += dir) {

             fCharIndices[out] = i;

         }

     }

     if (fInsertionList == NULL) {

         fInsertionList = new LEInsertionList(rightToLeft);

         if (fInsertionList == NULL) {

             LE_DELETE_ARRAY(fCharIndices);

             fCharIndices = NULL;

             LE_DELETE_ARRAY(fGlyphs);

             fGlyphs = NULL;

             success = LE_MEMORY_ALLOCATION_ERROR;

             return;

         }

     }

 }

 // FIXME: do we want to initialize the positions to [0, 0]?

 le_int32 LEGlyphStorage::allocatePositions(LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return -1;

     }

     if (fPositions != NULL) {

         LE_DELETE_ARRAY(fPositions);

     }

     fPositions = LE_NEW_ARRAY(float, 2 * (fGlyphCount + 1));

     if (fPositions == NULL) {

         success = LE_MEMORY_ALLOCATION_ERROR;

         return -1;

     }

     return fGlyphCount;

 }

 // FIXME: do we want to initialize the aux data to NULL?

 le_int32 LEGlyphStorage::allocateAuxData(LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return -1;

     }

     fAuxData = LE_NEW_ARRAY(void *, fGlyphCount);

     if (fAuxData == NULL) {

         success = LE_MEMORY_ALLOCATION_ERROR;

         return -1;

     }

     return fGlyphCount;

 }

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

 {

     le_int32 i;

     if (LE_FAILURE(success)) {

         return;

     }

     if (charIndices == NULL) {

         success = LE_ILLEGAL_ARGUMENT_ERROR;

         return;

     }

     if (fCharIndices == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return;

     }

     for (i = 0; i < fGlyphCount; i += 1) {

         charIndices[i] = fCharIndices[i] + indexBase;

     }

 }

 void LEGlyphStorage::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

       return;

     }

     if (charIndices == NULL) {

       success = LE_ILLEGAL_ARGUMENT_ERROR;

       return;

     }

     if (fCharIndices == NULL) {

       success = LE_NO_LAYOUT_ERROR;

       return;

     }

     LE_ARRAY_COPY(charIndices, fCharIndices, fGlyphCount);

 }

 // Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits

 void LEGlyphStorage::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const

 {

     le_int32 i;

     if (LE_FAILURE(success)) {

         return;

     }

     if (glyphs == NULL) {

         success = LE_ILLEGAL_ARGUMENT_ERROR;

         return;

     }

     if (fGlyphs == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return;

     }

     for (i = 0; i < fGlyphCount; i += 1) {

         glyphs[i] = fGlyphs[i] | extraBits;

     }

 }

 void LEGlyphStorage::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

       return;

     }

     if (glyphs == NULL) {

       success = LE_ILLEGAL_ARGUMENT_ERROR;

       return;

     }

     if (fGlyphs == NULL) {

       success = LE_NO_LAYOUT_ERROR;

       return;

     }

     LE_ARRAY_COPY(glyphs, fGlyphs, fGlyphCount);

 }

 LEGlyphID LEGlyphStorage::getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

         return 0xFFFF;

     }

     if (fGlyphs == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return 0xFFFF;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return 0xFFFF;

     }

     return fGlyphs[glyphIndex];

 }

 void LEGlyphStorage::setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (fGlyphs == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return;

     }

     fGlyphs[glyphIndex] = glyphID;

 }

 le_int32 LEGlyphStorage::getCharIndex(le_int32 glyphIndex, LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

         return -1;

     }

     if (fCharIndices == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return -1;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return -1;

     }

     return fCharIndices[glyphIndex];

 }

 void LEGlyphStorage::setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (fCharIndices == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return;

     }

     fCharIndices[glyphIndex] = charIndex;

 }

 void LEGlyphStorage::getAuxData(void *auxData[], LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

       return;

     }

     if (auxData == NULL) {

       success = LE_ILLEGAL_ARGUMENT_ERROR;

       return;

     }

     if (fAuxData == NULL) {

       success = LE_NO_LAYOUT_ERROR;

       return;

     }

     LE_ARRAY_COPY(auxData, fAuxData, fGlyphCount);

 }

 void *LEGlyphStorage::getAuxData(le_int32 glyphIndex, LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

         return NULL;

     }

     if (fAuxData == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return NULL;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return NULL;

     }

     return fAuxData[glyphIndex];

 }

 void LEGlyphStorage::setAuxData(le_int32 glyphIndex, void *auxData, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (fAuxData == NULL) {

         success = LE_NO_LAYOUT_ERROR;

         return;

     }

     if (glyphIndex < 0 || glyphIndex >= fGlyphCount) {

         success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

         return;

     }

     fAuxData[glyphIndex] = auxData;

 }

 void LEGlyphStorage::getGlyphPositions(float positions[], LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

       return;

     }

     if (positions == NULL) {

       success = LE_ILLEGAL_ARGUMENT_ERROR;

       return;

     }

     if (fPositions == NULL) {

       success = LE_NO_LAYOUT_ERROR;

       return;

     }

     LE_ARRAY_COPY(positions, fPositions, fGlyphCount * 2 + 2);

 }

 void LEGlyphStorage::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const

 {

     if (LE_FAILURE(success)) {

       return;

     }

     if (glyphIndex < 0 || glyphIndex > fGlyphCount) {

       success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

       return;

     }

     if (fPositions == NULL) {

       success = LE_NO_LAYOUT_ERROR;

       return;

     }

     x = fPositions[glyphIndex * 2];

     y = fPositions[glyphIndex * 2 + 1];

 }

 void LEGlyphStorage::setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (glyphIndex < 0 || glyphIndex > fGlyphCount) {

       success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

       return;

     }

     fPositions[glyphIndex * 2]     = x;

     fPositions[glyphIndex * 2 + 1] = y;

 }

 void LEGlyphStorage::adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success)

 {

     if (LE_FAILURE(success)) {

         return;

     }

     if (glyphIndex < 0 || glyphIndex > fGlyphCount) {

       success = LE_INDEX_OUT_OF_BOUNDS_ERROR;

       return;

     }

     fPositions[glyphIndex * 2]     += xAdjust;

     fPositions[glyphIndex * 2 + 1] += yAdjust;

 }

 void LEGlyphStorage::adoptGlyphArray(LEGlyphStorage &from)

 {

     if (fGlyphs != NULL) {

         LE_DELETE_ARRAY(fGlyphs);

     }

     fGlyphs = from.fGlyphs;

     from.fGlyphs = NULL;

     if (fInsertionList != NULL) {

         delete fInsertionList;

     }

     fInsertionList = from.fInsertionList;

     from.fInsertionList = NULL;

 }

 void LEGlyphStorage::adoptCharIndicesArray(LEGlyphStorage &from)

 {

     if (fCharIndices != NULL) {

         LE_DELETE_ARRAY(fCharIndices);

     }

     fCharIndices = from.fCharIndices;

     from.fCharIndices = NULL;

 }

 void LEGlyphStorage::adoptPositionArray(LEGlyphStorage &from)

 {

     if (fPositions != NULL) {

         LE_DELETE_ARRAY(fPositions);

     }

     fPositions = from.fPositions;

     from.fPositions = NULL;

 }

 void LEGlyphStorage::adoptAuxDataArray(LEGlyphStorage &from)

 {

     if (fAuxData != NULL) {

         LE_DELETE_ARRAY(fAuxData);

     }

     fAuxData = from.fAuxData;

     from.fAuxData = NULL;

 }

 void LEGlyphStorage::adoptGlyphCount(LEGlyphStorage &from)

 {

     fGlyphCount = from.fGlyphCount;

 }

 void LEGlyphStorage::adoptGlyphCount(le_int32 newGlyphCount)

 {

     fGlyphCount = newGlyphCount;

 }

 LEGlyphID *LEGlyphStorage::insertGlyphs(le_int32  atIndex, le_int32 insertCount,

     LEErrorCode& success)

 {

     return fInsertionList->insert(atIndex, insertCount, success);

 }

 le_int32 LEGlyphStorage::applyInsertions()

 {

     le_int32 growAmount = fInsertionList->getGrowAmount();

     if (growAmount == 0) {

         return fGlyphCount;

     }

     le_int32 newGlyphCount = fGlyphCount + growAmount;

     LEGlyphID *newGlyphs = (LEGlyphID *) LE_GROW_ARRAY(fGlyphs, newGlyphCount);

     if (!newGlyphs) {

         // Could not grow the glyph array

         return fGlyphCount;

     }

     fGlyphs = newGlyphs;

     le_int32 *newCharIndices = (le_int32 *) LE_GROW_ARRAY(fCharIndices, newGlyphCount);

     if (!newCharIndices) {

         // Could not grow the glyph array

         return fGlyphCount;

     }

     fCharIndices = newCharIndices;

     if (fAuxData != NULL) {

         void **newAuxData = (void **) LE_GROW_ARRAY(fAuxData, newGlyphCount);

         if (!newAuxData) {

             // could not grow the aux data array

             return fGlyphCount;

         }

         fAuxData = newAuxData;

     }

     fSrcIndex  = fGlyphCount - 1;

     fDestIndex = newGlyphCount - 1;

 #if 0

     // If the current position is at the end of the array

     // update it to point to the end of the new array. The

     // insertion callback will handle all other cases.

     // FIXME: this is left over from GlyphIterator, but there's no easy

     // way to implement this here... it seems that GlyphIterator doesn't

     // really need it 'cause the insertions don't get  applied until after a

     // complete pass over the glyphs, after which the iterator gets reset anyhow...

     // probably better to just document that for LEGlyphStorage and GlyphIterator...

     if (position == glyphCount) {

         position = newGlyphCount;

     }

 #endif

     fInsertionList->applyInsertions(this);

     fInsertionList->reset();

     return fGlyphCount = newGlyphCount;

 }

 le_bool LEGlyphStorage::applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[])

 {

 #if 0

     // if the current position is within the block we're shifting

     // it needs to be updated to the current glyph's

     // new location.

     // FIXME: this is left over from GlyphIterator, but there's no easy

     // way to implement this here... it seems that GlyphIterator doesn't

     // really need it 'cause the insertions don't get  applied until after a

     // complete pass over the glyphs, after which the iterator gets reset anyhow...

     // probably better to just document that for LEGlyphStorage and GlyphIterator...

     if (position >= atPosition && position <= fSrcIndex) {

         position += fDestIndex - fSrcIndex;

     }

 #endif

     if (fAuxData != NULL) {

         le_int32 src = fSrcIndex, dest = fDestIndex;

         while (src > atPosition) {

             fAuxData[dest--] = fAuxData[src--];

         }

         for (le_int32 i = count - 1; i >= 0; i -= 1) {

             fAuxData[dest--] = fAuxData[atPosition];

         }

     }

     while (fSrcIndex > atPosition) {

         fGlyphs[fDestIndex]      = fGlyphs[fSrcIndex];

         fCharIndices[fDestIndex] = fCharIndices[fSrcIndex];

         fDestIndex -= 1;

         fSrcIndex  -= 1;

     }

     for (le_int32 i = count - 1; i >= 0; i -= 1) {

         fGlyphs[fDestIndex]      = newGlyphs[i];

         fCharIndices[fDestIndex] = fCharIndices[atPosition];

         fDestIndex -= 1;

     }

     // the source glyph we're pointing at

     // just got replaced by the insertion

     fSrcIndex -= 1;

     return FALSE;

 }

 void LEGlyphStorage::forMlylRakar(LEGlyphID aGlyphID)

 {

     le_int32 i, j;    

     if (fGlyphs == NULL) {

         return;

     }

     for (i = 0; i < fGlyphCount; i++) {

         if (fGlyphs[i] == aGlyphID) {

         	j = i - 1;

         	while (j>=0 && fGlyphs[j] == 0xFFFF) {

         		j--;

         	}

         	if (j>=0 && fGlyphs[j] != 0xFFFF && fGlyphs[j] != aGlyphID) {

         		fGlyphs[i] = fGlyphs[j];

         		fGlyphs[j] = aGlyphID;

         		le_int32 tempCharIndex = fCharIndices[j];

         		fCharIndices[j] = fCharIndices[i];

         		fCharIndices[i] = tempCharIndex;

         		void * tempAuxData = fAuxData[j];

         		fAuxData[j] = fAuxData[i];

         		fAuxData[i] = fAuxData[j];

         	}

         }        	

     }

 }

 U_NAMESPACE_END