--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/textshaperplugin/IcuSource/layout/LEGlyphStorage.h Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,518 @@
+/*
+ **********************************************************************
+ * Copyright (C) 1998-2005, International Business Machines
+ * Corporation and others. All Rights Reserved.
+ **********************************************************************
+ */
+
+#ifndef __LEGLYPHSTORAGE_H
+#define __LEGLYPHSTORAGE_H
+
+#include "LETypes.h"
+#include "LEInsertionList.h"
+
+/**
+ * \file
+ * \brief C++ API: This class encapsulates the per-glyph storage used by the ICU LayoutEngine.
+ */
+
+U_NAMESPACE_BEGIN
+
+/**
+ * This class encapsulates the per-glyph storage used by the ICU LayoutEngine.
+ * For each glyph it holds the glyph ID, the index of the backing store character
+ * which produced the glyph, the X and Y position of the glyph and an auxillary data
+ * pointer.
+ *
+ * The storage is growable using the <code>LEInsertionList</code> class.
+ *
+ *
+ * @see LEInsertionList.h
+ *
+ * @draft ICU 3.0
+ */
+class U_LAYOUT_API LEGlyphStorage : public UObject, protected LEInsertionCallback
+{
+private:
+ /**
+ * The number of entries in the per-glyph arrays.
+ *
+ * @internal
+ */
+ le_int32 fGlyphCount;
+
+ /**
+ * The glyph ID array.
+ *
+ * @internal
+ */
+ LEGlyphID *fGlyphs;
+
+ /**
+ * The char indices array.
+ *
+ * @internal
+ */
+ le_int32 *fCharIndices;
+
+ /**
+ * The glyph positions array.
+ *
+ * @internal
+ */
+ float *fPositions;
+
+ /**
+ * The auxillary data array.
+ *
+ * @internal
+ */
+ void **fAuxData;
+
+
+ /**
+ * The insertion list, used to grow the above arrays.
+ *
+ * @internal
+ */
+ LEInsertionList *fInsertionList;
+
+ /**
+ * The source index while growing the data arrays.
+ *
+ * @internal
+ */
+ le_int32 fSrcIndex;
+
+ /**
+ * The destination index used while growing the data arrays.
+ *
+ * @internal
+ */
+ le_int32 fDestIndex;
+
+protected:
+ /**
+ * This implements <code>LEInsertionCallback</code>. The <code>LEInsertionList</code>
+ * will call this method once for each insertion.
+ *
+ * @param atPosition the position of the insertion
+ * @param count the number of glyphs being inserted
+ * @param newGlyphs the address of the new glyph IDs
+ *
+ * @return <code>true</code> if <code>LEInsertionList</code> should stop
+ * processing the insertion list after this insertion.
+ *
+ * @see LEInsertionList.h
+ *
+ * @draft ICU 3.0
+ */
+ virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]);
+
+public:
+
+ /**
+ * Allocates an empty <code>LEGlyphStorage</code> object. You must call
+ * <code>allocateGlyphArray, allocatePositions and allocateAuxData</code>
+ * to allocate the data.
+ */
+ LEGlyphStorage();
+
+ /**
+ * The destructor. This will deallocate all of the arrays.
+ */
+ ~LEGlyphStorage();
+
+ /**
+ * This method returns the number of glyphs in the glyph array.
+ *
+ * @return the number of glyphs in the glyph array
+ *
+ * @draft ICU 3.0
+ */
+ inline le_int32 getGlyphCount() const;
+
+ /**
+ * This method copies the glyph array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold all
+ * the glyphs.
+ *
+ * @param glyphs - the destiniation glyph array
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getGlyphs(LEGlyphID glyphs[], LEErrorCode &success) const;
+
+ /**
+ * This method copies the glyph array into a caller supplied array,
+ * ORing in extra bits. (This functionality is needed by the JDK,
+ * which uses 32 bits pre glyph idex, with the high 16 bits encoding
+ * the composite font slot number)
+ *
+ * @param glyphs - the destination (32 bit) glyph array
+ * @param extraBits - this value will be ORed with each glyph index
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getGlyphs(le_uint32 glyphs[], le_uint32 extraBits, LEErrorCode &success) const;
+
+ /**
+ * This method copies the character index array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold a
+ * character index for each glyph.
+ *
+ * @param charIndices - the destiniation character index array
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getCharIndices(le_int32 charIndices[], LEErrorCode &success) const;
+
+ /**
+ * This method copies the character index array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold a
+ * character index for each glyph.
+ *
+ * @param charIndices - the destiniation character index array
+ * @param indexBase - an offset which will be added to each index
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const;
+
+ /**
+ * This method copies the position array into a caller supplied array.
+ * The caller must ensure that the array is large enough to hold an
+ * X and Y position for each glyph, plus an extra X and Y for the
+ * advance of the last glyph.
+ *
+ * @param positions - the destiniation position array
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getGlyphPositions(float positions[], LEErrorCode &success) const;
+
+ /**
+ * This method returns the X and Y position of the glyph at
+ * the given index.
+ *
+ * Input parameters:
+ * @param glyphIndex - the index of the glyph
+ *
+ * Output parameters:
+ * @param x - the glyph's X position
+ * @param y - the glyph's Y position
+ * @param success - set to an error code if the operation fails
+ *
+ * @draft ICU 3.0
+ */
+ void getGlyphPosition(le_int32 glyphIndex, float &x, float &y, LEErrorCode &success) const;
+
+ /**
+ * This method allocates the glyph array, the char indices array and the insertion list. You
+ * must call this method before using the object. This method also initializes the char indices
+ * array.
+ *
+ * @param initialGlyphCount the initial size of the glyph and char indices arrays.
+ * @param rightToLeft <code>true</code> if the original input text is right to left.
+ * @param success set to an error code if the storage cannot be allocated of if the initial
+ * glyph count is not positive.
+ *
+ * @draft ICU 3.0
+ */
+ void allocateGlyphArray(le_int32 initialGlyphCount, le_bool rightToLeft, LEErrorCode &success);
+
+ /**
+ * This method allocates the storage for the glyph positions. It allocates one extra X, Y
+ * position pair for the position just after the last glyph.
+ *
+ * @param success set to an error code if the positions array cannot be allocated.
+ *
+ * @return the number of X, Y position pairs allocated.
+ *
+ * @draft ICU 3.0
+ */
+ le_int32 allocatePositions(LEErrorCode &success);
+
+ /**
+ * This method allocates the storage for the auxillary glyph data.
+ *
+ * @param success set to an error code if the aulillary data array cannot be allocated.
+ *
+ * @return the size of the auxillary data array.
+ *
+ * @draft ICU 3.0
+ */
+ le_int32 allocateAuxData(LEErrorCode &success);
+
+ /**
+ * Copy the entire auxillary data array.
+ *
+ * @param auxData the auxillary data array will be copied to this address
+ * @param success set to an error code if the data cannot be copied
+ *
+ * @draft ICU 3.0
+ */
+ void getAuxData(void *auxData[], LEErrorCode &success) const;
+
+ /**
+ * Get the glyph ID for a particular glyph.
+ *
+ * @param glyphIndex the index into the glyph array
+ * @param success set to an error code if the glyph ID cannot be retrieved.
+ *
+ * @return the glyph ID
+ *
+ * @draft ICU 3.0
+ */
+ LEGlyphID getGlyphID(le_int32 glyphIndex, LEErrorCode &success) const;
+
+ /**
+ * Get the char index for a particular glyph.
+ *
+ * @param glyphIndex the index into the glyph array
+ * @param success set to an error code if the char index cannot be retrieved.
+ *
+ * @return the character index
+ *
+ * @draft ICU 3.0
+ */
+ le_int32 getCharIndex(le_int32 glyphIndex, LEErrorCode &success) const;
+
+
+ /**
+ * Get the auxillary data for a particular glyph.
+ *
+ * @param glyphIndex the index into the glyph array
+ * @param success set to an error code if the auxillary data cannot be retrieved.
+ *
+ * @return the auxillary data
+ *
+ * @draft ICU 3.0
+ */
+ void *getAuxData(le_int32 glyphIndex, LEErrorCode &success) const;
+
+ /**
+ * This operator allows direct access to the glyph array
+ * using the index operator.
+ *
+ * @param glyphIndex the index into the glyph array
+ *
+ * @return a reference to the given location in the glyph array
+ *
+ * @draft ICU 3.0
+ */
+ inline LEGlyphID &operator[](le_int32 glyphIndex) const;
+
+ /**
+ * Call this method to replace a single glyph in the glyph array
+ * with multiple glyphs. This method uses the <code>LEInsertionList</code>
+ * to do the insertion. It returns the address of storage where the new
+ * glyph IDs can be stored. They will not actually be inserted into the
+ * glyph array until <code>applyInsertions</code> is called.
+ *
+ * @param atIndex the index of the glyph to be replaced
+ * @param insertCount the number of glyphs to replace it with
+ * @param success set to an error code if the auxillary data cannot be retrieved.
+ *
+ * @return the address at which to store the replacement glyphs.
+ *
+ * @see LEInsetionList.h
+ *
+ * @draft ICU 3.0
+ */
+ LEGlyphID *insertGlyphs(le_int32 atIndex, le_int32 insertCount,
+ LEErrorCode& success);
+
+ /**
+ * This method causes all of the glyph insertions recorded by
+ * <code>insertGlyphs</code> to be applied to the glyph array. The
+ * new slots in the char indices and the auxillary data arrays
+ * will be filled in with the values for the glyph being replaced.
+ *
+ * @return the new size of the glyph array
+ *
+ * @see LEInsertionList.h
+ *
+ * @draft ICU 3.0
+ */
+ le_int32 applyInsertions();
+
+ /**
+ * Set the glyph ID for a particular glyph.
+ *
+ * @param glyphIndex the index of the glyph
+ * @param glyphID the new glyph ID
+ * @param success will be set to an error code if the glyph ID cannot be set.
+ *
+ * @draft ICU 3.0
+ */
+ void setGlyphID(le_int32 glyphIndex, LEGlyphID glyphID, LEErrorCode &success);
+
+ /**
+ * Set the char index for a particular glyph.
+ *
+ * @param glyphIndex the index of the glyph
+ * @param charIndex the new char index
+ * @param success will be set to an error code if the char index cannot be set.
+ *
+ * @draft ICU 3.0
+ */
+ void setCharIndex(le_int32 glyphIndex, le_int32 charIndex, LEErrorCode &success);
+
+ /**
+ * Set the X, Y position for a particular glyph.
+ *
+ * @param glyphIndex the index of the glyph
+ * @param x the new X position
+ * @param y the new Y position
+ * @param success will be set to an error code if the position cannot be set.
+ *
+ * @draft ICU 3.0
+ */
+ void setPosition(le_int32 glyphIndex, float x, float y, LEErrorCode &success);
+
+ /**
+ * Adjust the X, Y position for a particular glyph.
+ *
+ * @param glyphIndex the index of the glyph
+ * @param xAdjust the adjustment to the glyph's X position
+ * @param yAdjust the adjustment to the glyph's Y position
+ * @param success will be set to an error code if the glyph's position cannot be adjusted.
+ *
+ * @draft ICU 3.0
+ */
+ void adjustPosition(le_int32 glyphIndex, float xAdjust, float yAdjust, LEErrorCode &success);
+
+ /**
+ * Set the auxillary data for a particular glyph.
+ *
+ * @param glyphIndex the index of the glyph
+ * @param auxData the new auxillary data
+ * @param success will be set to an error code if the auxillary data cannot be set.
+ *
+ * @draft ICU 3.0
+ */
+ void setAuxData(le_int32 glyphIndex, void *auxData, LEErrorCode &success);
+
+ /**
+ * Delete the glyph array and replace it with the one
+ * in <code>from</code>. Set the glyph array pointer
+ * in <code>from</code> to <code>NULL</code>.
+ *
+ * @param from the <code>LEGlyphStorage</code> object from which
+ * to get the new glyph array.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptGlyphArray(LEGlyphStorage &from);
+
+ /**
+ * Delete the char indices array and replace it with the one
+ * in <code>from</code>. Set the char indices array pointer
+ * in <code>from</code> to <code>NULL</code>.
+ *
+ * @param from the <code>LEGlyphStorage</code> object from which
+ * to get the new char indices array.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptCharIndicesArray(LEGlyphStorage &from);
+
+ /**
+ * Delete the position array and replace it with the one
+ * in <code>from</code>. Set the position array pointer
+ * in <code>from</code> to <code>NULL</code>.
+ *
+ * @param from the <code>LEGlyphStorage</code> object from which
+ * to get the new position array.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptPositionArray(LEGlyphStorage &from);
+
+ /**
+ * Delete the auxillary data array and replace it with the one
+ * in <code>from</code>. Set the auxillary data array pointer
+ * in <code>from</code> to <code>NULL</code>.
+ *
+ * @param from the <code>LEGlyphStorage</code> object from which
+ * to get the new auxillary data array.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptAuxDataArray(LEGlyphStorage &from);
+
+ /**
+ * Change the glyph count of this object to be the same
+ * as the one in <code>from</code>.
+ *
+ * @param from the <code>LEGlyphStorage</code> object from which
+ * to get the new glyph count.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptGlyphCount(LEGlyphStorage &from);
+
+ /**
+ * Change the glyph count of this object to the given value.
+ *
+ * @param newGlyphCount the new glyph count.
+ *
+ * @draft ICU 3.0
+ */
+ void adoptGlyphCount(le_int32 newGlyphCount);
+
+ /**
+ * This method frees the glyph, character index, position and
+ * auxillary data arrays so that the LayoutEngine can be reused
+ * to layout a different characer array. (This method is also called
+ * by the destructor)
+ *
+ * @draft ICU 3.0
+ */
+ void reset();
+
+ /**
+ * This method move glyph of Malayalam RAKAR to the left of the preceding
+ * consonant cluster.
+ *
+ * @param aGlyphID the <code>LEGlyphID</code> of RAKAR
+ *
+ * @draft Added by Nokia
+ */
+ void forMlylRakar(LEGlyphID aGlyphID);
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for the actual class.
+ *
+ * @draft ICU 3.0
+ */
+ virtual UClassID getDynamicClassID() const;
+
+ /**
+ * ICU "poor man's RTTI", returns a UClassID for this class.
+ *
+ * @draft ICU 3.0
+ */
+ static UClassID getStaticClassID();
+};
+
+inline le_int32 LEGlyphStorage::getGlyphCount() const
+{
+ return fGlyphCount;
+}
+
+inline LEGlyphID &LEGlyphStorage::operator[](le_int32 glyphIndex) const
+{
+ return fGlyphs[glyphIndex];
+}
+
+
+U_NAMESPACE_END
+#endif
+