/*

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

 *   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