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

/*
 **********************************************************************
 *   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) {
        // FIXME: check this for failure?
        fInsertionList = new LEInsertionList(rightToLeft);
    }
}

// FIXME: do we want to initialize the positions to [0, 0]?
le_int32 LEGlyphStorage::allocatePositions(LEErrorCode &success)
{
    if (LE_FAILURE(success)) {
        return -1;
    }

    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;
}

// FIXME: add error checking?
LEGlyphID *LEGlyphStorage::insertGlyphs(le_int32  atIndex, le_int32 insertCount)
{
    return fInsertionList->insert(atIndex, insertCount);
}

le_int32 LEGlyphStorage::applyInsertions()
{
    le_int32 growAmount = fInsertionList->getGrowAmount();

    if (growAmount == 0) {
        return fGlyphCount;
    }

    le_int32 newGlyphCount = fGlyphCount + growAmount;

    fGlyphs      = (LEGlyphID *) LE_GROW_ARRAY(fGlyphs,      newGlyphCount);
    fCharIndices = (le_int32 *)  LE_GROW_ARRAY(fCharIndices, newGlyphCount);

    if (fAuxData != NULL) {
        fAuxData     = (void **) LE_GROW_ARRAY(fAuxData,     newGlyphCount);
    }

    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;
}

U_NAMESPACE_END
Commit	Line	Data
374ca955 A	1	/*
	2	**********************************************************************
	3	* Copyright (C) 1998-2004, International Business Machines
	4	* Corporation and others. All Rights Reserved.
	5	**********************************************************************
	6	*/
	7
	8	#include "LETypes.h"
	9	#include "LEInsertionList.h"
	10	#include "LEGlyphStorage.h"
	11
	12	U_NAMESPACE_BEGIN
	13
	14	UOBJECT_DEFINE_RTTI_IMPLEMENTATION(LEGlyphStorage)
	15
	16	LEGlyphStorage::LEGlyphStorage()
	17	: fGlyphCount(0), fGlyphs(NULL), fCharIndices(NULL), fPositions(NULL),
	18	fAuxData(NULL), fInsertionList(NULL), fSrcIndex(0), fDestIndex(0)
	19	{
	20	// nothing else to do!
	21	}
	22
	23	LEGlyphStorage::~LEGlyphStorage()
	24	{
	25	reset();
	26	}
	27
	28	void LEGlyphStorage::reset()
	29	{
	30	fGlyphCount = 0;
	31
	32	if (fPositions != NULL) {
	33	LE_DELETE_ARRAY(fPositions);
	34	fPositions = NULL;
	35	}
	36
	37	if (fAuxData != NULL) {
	38	LE_DELETE_ARRAY(fAuxData);
	39	fAuxData = NULL;
	40	}
	41
	42	if (fInsertionList != NULL) {
	43	delete fInsertionList;
	44	fInsertionList = NULL;
	45	}
	46
	47	if (fCharIndices != NULL) {
	48	LE_DELETE_ARRAY(fCharIndices);
	49	fCharIndices = NULL;
	50	}
	51
	52	if (fGlyphs != NULL) {
	53	LE_DELETE_ARRAY(fGlyphs);
	54	fGlyphs = NULL;
	55	}
	56	}
	57
	58	// FIXME: This might get called more than once, for various reasons. Is
	59	// testing for pre-existing glyph and charIndices arrays good enough?
	60	void LEGlyphStorage::allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success)
	61	{
	62	if (LE_FAILURE(success)) {
	63	return;
	64	}
65
66	if (initialGlyphCount <= 0) {
67	success = LE_ILLEGAL_ARGUMENT_ERROR;
68	return;
69	}
70
71	if (fGlyphs == NULL) {
72	fGlyphCount = initialGlyphCount;
73	fGlyphs = LE_NEW_ARRAY(LEGlyphID, fGlyphCount);
74
75	if (fGlyphs == NULL) {
76	success = LE_MEMORY_ALLOCATION_ERROR;
77	return;
78	}
79	}
80
81	if (fCharIndices == NULL) {
82	fCharIndices = LE_NEW_ARRAY(le_int32, fGlyphCount);
83
84	if (fCharIndices == NULL) {
85	LE_DELETE_ARRAY(fGlyphs);
86	fGlyphs = NULL;
87	success = LE_MEMORY_ALLOCATION_ERROR;
88	return;
89	}
90
91	// Initialize the charIndices array
92	le_int32 i, count = fGlyphCount, dir = 1, out = 0;
93
94	if (rightToLeft) {
95	out = fGlyphCount - 1;
96	dir = -1;
97	}
98
99	for (i = 0; i < count; i += 1, out += dir) {
100	fCharIndices[out] = i;
101	}
102	}
103
104	if (fInsertionList == NULL) {
105	// FIXME: check this for failure?
106	fInsertionList = new LEInsertionList(rightToLeft);
107	}
108	}
109
110	// FIXME: do we want to initialize the positions to [0, 0]?
111	le_int32 LEGlyphStorage::allocatePositions(LEErrorCode &success)
112	{
113	if (LE_FAILURE(success)) {
114	return -1;
115	}
116
117	fPositions = LE_NEW_ARRAY(float, 2 * (fGlyphCount + 1));
118
119	if (fPositions == NULL) {
120	success = LE_MEMORY_ALLOCATION_ERROR;
121	return -1;
122	}
123
124	return fGlyphCount;
125	}
126
127	// FIXME: do we want to initialize the aux data to NULL?
128	le_int32 LEGlyphStorage::allocateAuxData(LEErrorCode &success)
129	{
130	if (LE_FAILURE(success)) {
131	return -1;
132	}
133
134	fAuxData = LE_NEW_ARRAY(void *, fGlyphCount);
135
136	if (fAuxData == NULL) {
137	success = LE_MEMORY_ALLOCATION_ERROR;
138	return -1;
139	}
140
141	return fGlyphCount;
142	}
143
144	void LEGlyphStorage::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
145	{
146	le_int32 i;
147
148	if (LE_FAILURE(success)) {
149	return;
150	}
151
152	if (charIndices == NULL) {
153	success = LE_ILLEGAL_ARGUMENT_ERROR;
154	return;
155	}
156
157	if (fCharIndices == NULL) {
158	success = LE_NO_LAYOUT_ERROR;
159	return;
160	}
161
162	for (i = 0; i < fGlyphCount; i += 1) {
163	charIndices[i] = fCharIndices[i] + indexBase;
164	}
165	}
166
167	void LEGlyphStorage::getCharIndices(le_int32 charIndices[], LEErrorCode &success) const
168	{
169	if (LE_FAILURE(success)) {
170	return;
171	}
172
173	if (charIndices == NULL) {
174	success = LE_ILLEGAL_ARGUMENT_ERROR;
175	return;
176	}
177
178	if (fCharIndices == NULL) {
179	success = LE_NO_LAYOUT_ERROR;
180	return;
181	}
182
183	LE_ARRAY_COPY(charIndices, fCharIndices, fGlyphCount);
184	}
185
186	// Copy the glyphs into caller's (32-bit) glyph array, OR in extraBits
187	void LEGlyphStorage::getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const
188	{
189	le_int32 i;
190
191	if (LE_FAILURE(success)) {
192	return;
193	}
194
195	if (glyphs == NULL) {
196	success = LE_ILLEGAL_ARGUMENT_ERROR;
197	return;
198	}
199
200	if (fGlyphs == NULL) {
201	success = LE_NO_LAYOUT_ERROR;
202	return;
203	}
204
205	for (i = 0; i < fGlyphCount; i += 1) {
206	glyphs[i] = fGlyphs[i] \| extraBits;
207	}
208	}
209
210	void LEGlyphStorage::getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const
211	{
212	if (LE_FAILURE(success)) {
213	return;
214	}
215
216	if (glyphs == NULL) {
217	success = LE_ILLEGAL_ARGUMENT_ERROR;
218	return;
219	}
220
221	if (fGlyphs == NULL) {
222	success = LE_NO_LAYOUT_ERROR;
223	return;
224	}
225
226	LE_ARRAY_COPY(glyphs, fGlyphs, fGlyphCount);
227	}
228
229	LEGlyphID LEGlyphStorage::getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const
230	{
231	if (LE_FAILURE(success)) {
232	return 0xFFFF;
233	}
234
235	if (fGlyphs == NULL) {
236	success = LE_NO_LAYOUT_ERROR;
237	return 0xFFFF;
238	}
239
240	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
241	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
242	return 0xFFFF;
243	}
244
245	return fGlyphs[glyphIndex];
246	}
247
248	void LEGlyphStorage::setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success)
249	{
250	if (LE_FAILURE(success)) {
251	return;
252	}
253
254	if (fGlyphs == NULL) {
255	success = LE_NO_LAYOUT_ERROR;
256	return;
257	}
258
259	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
260	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
261	return;
262	}
263
264	fGlyphs[glyphIndex] = glyphID;
265	}
266
267	le_int32 LEGlyphStorage::getCharIndex(le_int32 glyphIndex, LEErrorCode &success) const
268	{
269	if (LE_FAILURE(success)) {
270	return -1;
271	}
272
273	if (fCharIndices == NULL) {
274	success = LE_NO_LAYOUT_ERROR;
275	return -1;
276	}
277
278	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
279	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
280	return -1;
281	}
282
283	return fCharIndices[glyphIndex];
284	}
285
286	void LEGlyphStorage::setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success)
287	{
288	if (LE_FAILURE(success)) {
289	return;
290	}
291
292	if (fCharIndices == NULL) {
293	success = LE_NO_LAYOUT_ERROR;
294	return;
295	}
296
297	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
298	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
299	return;
300	}
301
302	fCharIndices[glyphIndex] = charIndex;
303	}
304
305	void LEGlyphStorage::getAuxData(void *auxData[], LEErrorCode &success) const
306	{
307	if (LE_FAILURE(success)) {
308	return;
309	}
310
311	if (auxData == NULL) {
312	success = LE_ILLEGAL_ARGUMENT_ERROR;
313	return;
314	}
315
316	if (fAuxData == NULL) {
317	success = LE_NO_LAYOUT_ERROR;
318	return;
319	}
320
321	LE_ARRAY_COPY(auxData, fAuxData, fGlyphCount);
322	}
323
324	void *LEGlyphStorage::getAuxData(le_int32 glyphIndex, LEErrorCode &success) const
325	{
326	if (LE_FAILURE(success)) {
327	return NULL;
328	}
329
330	if (fAuxData == NULL) {
331	success = LE_NO_LAYOUT_ERROR;
332	return NULL;
333	}
334
335	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
336	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
337	return NULL;
338	}
339
340	return fAuxData[glyphIndex];
341	}
342
343	void LEGlyphStorage::setAuxData(le_int32 glyphIndex, void *auxData, LEErrorCode &success)
344	{
345	if (LE_FAILURE(success)) {
346	return;
347	}
348
349	if (fAuxData == NULL) {
350	success = LE_NO_LAYOUT_ERROR;
351	return;
352	}
353
354	if (glyphIndex < 0 \|\| glyphIndex >= fGlyphCount) {
355	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
356	return;
357	}
358
359	fAuxData[glyphIndex] = auxData;
360	}
361
362	void LEGlyphStorage::getGlyphPositions(float positions[], LEErrorCode &success) const
363	{
364	if (LE_FAILURE(success)) {
365	return;
366	}
367
368	if (positions == NULL) {
369	success = LE_ILLEGAL_ARGUMENT_ERROR;
370	return;
371	}
372
373	if (fPositions == NULL) {
374	success = LE_NO_LAYOUT_ERROR;
375	return;
376	}
377
378	LE_ARRAY_COPY(positions, fPositions, fGlyphCount * 2 + 2);
379	}
380
381	void LEGlyphStorage::getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const
382	{
383	if (LE_FAILURE(success)) {
384	return;
385	}
386
387	if (glyphIndex < 0 \|\| glyphIndex > fGlyphCount) {
388	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
389	return;
390	}
391
392	if (fPositions == NULL) {
393	success = LE_NO_LAYOUT_ERROR;
394	return;
395	}
396
397	x = fPositions[glyphIndex * 2];
398	y = fPositions[glyphIndex * 2 + 1];
399	}
400
401	void LEGlyphStorage::setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success)
402	{
403	if (LE_FAILURE(success)) {
404	return;
405	}
406
407	if (glyphIndex < 0 \|\| glyphIndex > fGlyphCount) {
408	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
409	return;
410	}
411
412	fPositions[glyphIndex * 2] = x;
413	fPositions[glyphIndex * 2 + 1] = y;
414	}
415
416	void LEGlyphStorage::adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success)
417	{
418	if (LE_FAILURE(success)) {
419	return;
420	}
421
422	if (glyphIndex < 0 \|\| glyphIndex > fGlyphCount) {
423	success = LE_INDEX_OUT_OF_BOUNDS_ERROR;
424	return;
425	}
426
427	fPositions[glyphIndex * 2] += xAdjust;
428	fPositions[glyphIndex * 2 + 1] += yAdjust;
429	}
430
431	void LEGlyphStorage::adoptGlyphArray(LEGlyphStorage &from)
432	{
433	if (fGlyphs != NULL) {
434	LE_DELETE_ARRAY(fGlyphs);
435	}
436
437	fGlyphs = from.fGlyphs;
438	from.fGlyphs = NULL;
439
440	if (fInsertionList != NULL) {
441	delete fInsertionList;
442	}
443
444	fInsertionList = from.fInsertionList;
445	from.fInsertionList = NULL;
446	}
447
448	void LEGlyphStorage::adoptCharIndicesArray(LEGlyphStorage &from)
449	{
450	if (fCharIndices != NULL) {
451	LE_DELETE_ARRAY(fCharIndices);
452	}
453
454	fCharIndices = from.fCharIndices;
455	from.fCharIndices = NULL;
456	}
457
458	void LEGlyphStorage::adoptPositionArray(LEGlyphStorage &from)
459	{
460	if (fPositions != NULL) {
461	LE_DELETE_ARRAY(fPositions);
462	}
463
464	fPositions = from.fPositions;
465	from.fPositions = NULL;
466	}
467
468	void LEGlyphStorage::adoptAuxDataArray(LEGlyphStorage &from)
469	{
470	if (fAuxData != NULL) {
471	LE_DELETE_ARRAY(fAuxData);
472	}
473
474	fAuxData = from.fAuxData;
475	from.fAuxData = NULL;
476	}
477
478	void LEGlyphStorage::adoptGlyphCount(LEGlyphStorage &from)
479	{
480	fGlyphCount = from.fGlyphCount;
481	}
482
483	void LEGlyphStorage::adoptGlyphCount(le_int32 newGlyphCount)
484	{
485	fGlyphCount = newGlyphCount;
486	}
487
488	// FIXME: add error checking?
489	LEGlyphID *LEGlyphStorage::insertGlyphs(le_int32 atIndex, le_int32 insertCount)
490	{
491	return fInsertionList->insert(atIndex, insertCount);
492	}
493
494	le_int32 LEGlyphStorage::applyInsertions()
495	{
496	le_int32 growAmount = fInsertionList->getGrowAmount();
497
498	if (growAmount == 0) {
499	return fGlyphCount;
500	}
501
502	le_int32 newGlyphCount = fGlyphCount + growAmount;
503
504	fGlyphs = (LEGlyphID *) LE_GROW_ARRAY(fGlyphs, newGlyphCount);
505	fCharIndices = (le_int32 *) LE_GROW_ARRAY(fCharIndices, newGlyphCount);
506
507	if (fAuxData != NULL) {
508	fAuxData = (void **) LE_GROW_ARRAY(fAuxData, newGlyphCount);
509	}
510
511	fSrcIndex = fGlyphCount - 1;
512	fDestIndex = newGlyphCount - 1;
513
514	#if 0
515	// If the current position is at the end of the array
516	// update it to point to the end of the new array. The
517	// insertion callback will handle all other cases.
518	// FIXME: this is left over from GlyphIterator, but there's no easy
519	// way to implement this here... it seems that GlyphIterator doesn't
520	// really need it 'cause the insertions don't get applied until after a
521	// complete pass over the glyphs, after which the iterator gets reset anyhow...
522	// probably better to just document that for LEGlyphStorage and GlyphIterator...
523	if (position == glyphCount) {
524	position = newGlyphCount;
525	}
526	#endif
527
528	fInsertionList->applyInsertions(this);
529
530	fInsertionList->reset();
531
532	return fGlyphCount = newGlyphCount;
533	}
534
535	le_bool LEGlyphStorage::applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[])
536	{
537	#if 0
538	// if the current position is within the block we're shifting
539	// it needs to be updated to the current glyph's
540	// new location.
541	// FIXME: this is left over from GlyphIterator, but there's no easy
542	// way to implement this here... it seems that GlyphIterator doesn't
543	// really need it 'cause the insertions don't get applied until after a
544	// complete pass over the glyphs, after which the iterator gets reset anyhow...
545	// probably better to just document that for LEGlyphStorage and GlyphIterator...
546	if (position >= atPosition && position <= fSrcIndex) {
547	position += fDestIndex - fSrcIndex;
548	}
549	#endif
550
551	if (fAuxData != NULL) {
552	le_int32 src = fSrcIndex, dest = fDestIndex;
553
554	while (src > atPosition) {
555	fAuxData[dest--] = fAuxData[src--];
556	}
557
558	for (le_int32 i = count - 1; i >= 0; i -= 1) {
559	fAuxData[dest--] = fAuxData[atPosition];
560	}
561	}
562
563	while (fSrcIndex > atPosition) {
564	fGlyphs[fDestIndex] = fGlyphs[fSrcIndex];
565	fCharIndices[fDestIndex] = fCharIndices[fSrcIndex];
566
567	fDestIndex -= 1;
568	fSrcIndex -= 1;
569	}
570
571	for (le_int32 i = count - 1; i >= 0; i -= 1) {
572	fGlyphs[fDestIndex] = newGlyphs[i];
573	fCharIndices[fDestIndex] = fCharIndices[atPosition];
574
575	fDestIndex -= 1;
576	}
577
578	// the source glyph we're pointing at
579	// just got replaced by the insertion
580	fSrcIndex -= 1;
581
582	return FALSE;
583	}
584
585	U_NAMESPACE_END
586