icuSources/layout/LEInsertionList.h

   1 /*
   2  **********************************************************************
   3  *   Copyright (C) 1998-2006, International Business Machines
   4  *   Corporation and others.  All Rights Reserved.
   5  **********************************************************************
   6  */
   7
   8 #ifndef __LEINSERTIONLIST_H
   9 #define __LEINSERTIONLIST_H
  10
  11 #include "LETypes.h"
  12
  13 U_NAMESPACE_BEGIN
  14
  15 struct InsertionRecord;
  16
  17 /**
  18  * This class encapsulates the callback used by <code>LEInsertionList</code>
  19  * to apply an insertion from the insertion list.
  20  *
  21  * @internal
  22  */
  23 class U_LAYOUT_API LEInsertionCallback
  24 {
  25 public:
  26     /**
  27      * This method will be called by <code>LEInsertionList::applyInsertions</code> for each
  28      * entry on the insertion list.
  29      *
  30      * @param atPosition the position of the insertion
  31      * @param count the number of glyphs to insert
  32      * @param newGlyphs the address of the glyphs to insert
  33      *
  34      * @return <code>TRUE</code> if <code>LEInsertions::applyInsertions</code> should
  35      *         stop after applying this insertion.
  36      *
  37      * @internal
  38      */
  39     virtual le_bool applyInsertion(le_int32 atPosition, le_int32 count, LEGlyphID newGlyphs[]) = 0;
  40
  41     /**
  42      * The destructor
  43      */
  44      virtual ~LEInsertionCallback();
  45 };
  46
  47 /**
  48  * This class is used to keep track of insertions to an array of
  49  * <code>LEGlyphIDs</code>. The insertions are kept on a linked
  50  * list of <code>InsertionRecords</code> so that the glyph array
  51  * doesn't have to be grown for each insertion. The insertions are
  52  * stored on the list from leftmost to rightmost to make it easier
  53  * to do the insertions.
  54  *
  55  * The insertions are applied to the array by calling the
  56  * <code>applyInsertions</code> method, which calls a client
  57  * supplied <code>LEInsertionCallback</code> object to actually
  58  * apply the individual insertions.
  59  *
  60  * @internal
  61  */
  62 class LEInsertionList : public UObject
  63 {
  64 public:
  65     /**
  66      * Construct an empty insertion list.
  67      *
  68      * @param rightToLeft <code>TRUE</code> if the glyphs are stored
  69      *                    in the array in right to left order.
  70      *
  71      * @internal
  72      */
  73     LEInsertionList(le_bool rightToLeft);
  74
  75     /**
  76      * The destructor.
  77      */
  78     ~LEInsertionList();
  79
  80     /**
  81      * Add an entry to the insertion list.
  82      *
  83      * @param position the glyph at this position in the array will be
  84      *                 replaced by the new glyphs.
  85      * @param count the number of new glyphs
  86      *
  87      * @return the address of an array in which to store the new glyphs. This will
  88      *         <em>not</em> be in the glyph array.
  89      *
  90      * @internal
  91      */
  92     LEGlyphID *insert(le_int32 position, le_int32 count);
  93
  94     /**
  95      * Return the number of new glyphs that have been inserted.
  96      *
  97      * @return the number of new glyphs which have been inserted
  98      *
  99      * @internal
 100      */
 101     le_int32 getGrowAmount();
 102
 103     /**
 104      * Call the <code>LEInsertionCallback</code> once for each
 105      * entry on the insertion list.
 106      *
 107      * @param callback the <code>LEInsertionCallback</code> to call for each insertion.
 108      *
 109      * @return <code>TRUE</code> if <code>callback</code> returned <code>TRUE</code> to
 110      *         terminate the insertion list processing.
 111      *
 112      * @internal
 113      */
 114     le_bool applyInsertions(LEInsertionCallback *callback);
 115
 116     /**
 117      * Empty the insertion list and free all associated
 118      * storage.
 119      *
 120      * @internal
 121      */
 122     void reset();
 123
 124     /**
 125      * ICU "poor man's RTTI", returns a UClassID for the actual class.
 126      *
 127      * @stable ICU 2.8
 128      */
 129     virtual UClassID getDynamicClassID() const;
 130
 131     /**
 132      * ICU "poor man's RTTI", returns a UClassID for this class.
 133      *
 134      * @stable ICU 2.8
 135      */
 136     static UClassID getStaticClassID();
 137
 138 private:
 139
 140     /**
 141      * The head of the insertion list.
 142      *
 143      * @internal
 144      */
 145     InsertionRecord *head;
 146
 147     /**
 148      * The tail of the insertion list.
 149      *
 150      * @internal
 151      */
 152     InsertionRecord *tail;
 153
 154     /**
 155      * The total number of new glyphs on the insertion list.
 156      *
 157      * @internal
 158      */
 159     le_int32 growAmount;
 160
 161     /**
 162      * Set to <code>TRUE</code> if the glyphs are in right
 163      * to left order. Since we want the rightmost insertion
 164      * to be first on the list, we need to append the
 165      * insertions in this case. Otherwise they're prepended.
 166      *
 167      * @internal
 168      */
 169     le_bool  append;
 170 };
 171
 172 U_NAMESPACE_END
 173 #endif
 174