| /* |
| * (C) Copyright IBM Corp. 1998-2004. All Rights Reserved. |
| * |
| * The program is provided "as is" without any warranty express or |
| * implied, including the warranty of non-infringement and the implied |
| * warranties of merchantibility and fitness for a particular purpose. |
| * IBM will not be liable for any damages suffered by you as a result |
| * of using the Program. In no event will IBM be liable for any |
| * special, indirect or consequential damages or lost profits even if |
| * IBM has been advised of the possibility of their occurrence. IBM |
| * will not be liable for any third party claims against you. |
| */ |
| package com.ibm.richtext.styledtext; |
| |
| import com.ibm.richtext.textlayout.attributes.AttributeMap; |
| |
| import java.io.Externalizable; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.io.IOException; |
| import java.text.CharacterIterator; |
| |
| /** |
| * This class is an implementation of MText, a modifyable, styled text |
| * storage model. Additionally, it supports persistance through the |
| * Externalizable interface. |
| * @see MText |
| */ |
| |
| /* |
| 10/28/96 {jf} - split the character and paragraph style access and setter function around... |
| just to keep things interesting. |
| 8/7/96 {jf} - moved paragraph break implementation from AbstractText into Style text. |
| - added countStyles, getStyles, and ReplaceStyles implementation. |
| |
| 8/14/96 sfb eliminated StyleSheetIterator |
| |
| 8/29/96 {jbr} changed iter-based replace method - doesn't call at() unless it is safe to do so |
| Also, added checkStartAndLimit for debugging |
| |
| 7/31/98 Switched from Style to AttributeMap |
| |
| */ |
| |
| public final class StyledText extends MText implements Externalizable |
| { |
| static final String COPYRIGHT = |
| "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved"; |
| private static final int CURRENT_VERSION = 1; |
| private static final long serialVersionUID = 22356934; |
| |
| /* unicode storage */ |
| private MCharBuffer fCharBuffer; |
| /* character style storage */ |
| private MStyleBuffer fStyleBuffer; |
| /* paragraph style storage */ |
| private MParagraphBuffer fParagraphBuffer; |
| |
| private transient int fTimeStamp = 0; |
| private transient int[] fDamagedRange = { Integer.MAX_VALUE, |
| Integer.MIN_VALUE }; |
| |
| private static class ForceModifier extends StyleModifier { |
| |
| private AttributeMap fStyle = AttributeMap.EMPTY_ATTRIBUTE_MAP; |
| |
| void setStyle(AttributeMap style) { |
| |
| fStyle = style; |
| } |
| |
| public AttributeMap modifyStyle(AttributeMap style) { |
| |
| return fStyle; |
| } |
| } |
| |
| // Keep this around foruse in replaceCharStylesWith. OK since |
| // this class isn't threadsafe anyway. |
| private transient ForceModifier forceModifier = null; |
| |
| //====================================================== |
| // CONSTRUCTORS |
| //====================================================== |
| /** |
| * Create an empty text object. |
| */ |
| public StyledText() |
| { |
| this(0); |
| } |
| |
| /** |
| * Create an empty text object ready to hold at least capacity chars. |
| * @param capacity the minimum capacity of the internal text buffer |
| */ |
| public StyledText(int capacity) |
| { |
| fCharBuffer = capacity>0? new CharBuffer(capacity) : new CharBuffer(); |
| fStyleBuffer = new StyleBuffer(this, AttributeMap.EMPTY_ATTRIBUTE_MAP); |
| fParagraphBuffer = new ParagraphBuffer(fCharBuffer); |
| } |
| |
| /** |
| * Create a text object with the characters in the string, |
| * in the given style. |
| * @param string the initial contents |
| * @param initialStyle the style of the initial text |
| */ |
| public StyledText(String string, AttributeMap initialStyle) |
| { |
| fCharBuffer = new CharBuffer(string.length()); |
| fCharBuffer.replace(0, 0, string, 0, string.length()); |
| |
| fStyleBuffer = new StyleBuffer(this, initialStyle); |
| fParagraphBuffer = new ParagraphBuffer(fCharBuffer); |
| } |
| |
| /** |
| * Create a text object from the given source. |
| * @param source the text to copy |
| */ |
| public StyledText(MConstText source) { |
| this(); |
| append(source); |
| } |
| |
| /** |
| * Create a text object from a subrange of the given source. |
| * @param source the text to copy from |
| * @param srcStart the index of the first character to copy |
| * @param srcLimit the index after the last character to copy |
| */ |
| public StyledText(MConstText source, int srcStart, int srcLimit) { |
| this(); |
| replace(0, 0, source, srcStart, srcLimit); |
| } |
| |
| public void writeExternal(ObjectOutput out) throws IOException { |
| |
| out.writeInt(CURRENT_VERSION); |
| out.writeObject(fCharBuffer); |
| out.writeObject(fStyleBuffer); |
| out.writeObject(fParagraphBuffer); |
| } |
| |
| public void readExternal(ObjectInput in) throws IOException, |
| ClassNotFoundException { |
| |
| int version = in.readInt(); |
| if (version != CURRENT_VERSION) { |
| throw new IOException("Invalid version of StyledText: " + version); |
| } |
| fCharBuffer = (MCharBuffer) in.readObject(); |
| fStyleBuffer = (MStyleBuffer) in.readObject(); |
| fParagraphBuffer = (MParagraphBuffer) in.readObject(); |
| |
| resetDamagedRange(); |
| } |
| |
| //====================================================== |
| // MConstText INTERFACES |
| //====================================================== |
| |
| //-------------------------------------------------------- |
| // character access |
| //-------------------------------------------------------- |
| /** |
| * Return the character at offset <code>pos</code>. |
| * @param pos a valid offset into the text |
| * @return the character at offset <code>pos</code> |
| */ |
| public char at(int pos) |
| { |
| return fCharBuffer.at(pos); |
| } |
| |
| /** |
| * Copy the characters in the range [<code>start</code>, <code>limit</code>) |
| * into the array <code>dst</code>, beginning at <code>dstStart</code>. |
| * @param start offset of first character which will be copied into the array |
| * @param limit offset immediately after the last character which will be copied into the array |
| * @param dst array in which to copy characters. The length of <code>dst</code> must be at least |
| * (<code>dstStart + limit - start</code>). |
| */ |
| public void extractChars(int start, int limit, char[] dst, int dstStart) |
| { |
| fCharBuffer.at(start, limit, dst, dstStart); |
| } |
| |
| //------------------------------------------------------- |
| // text model creation |
| //------------------------------------------------------- |
| /** |
| * Create an MConstText containing the characters and styles in the range |
| * [<code>start</code>, <code>limit</code>). |
| * @param start offset of first character in the new text |
| * @param limit offset immediately after the last character in the new text |
| * @return an MConstText object containing the characters and styles in the given range |
| */ |
| public MConstText extract(int start, int limit) |
| { |
| return extractWritable(start, limit); |
| } |
| |
| /** |
| * Create an MText containing the characters and styles in the range |
| * [<code>start</code>, <code>limit</code>). |
| * @param start offset of first character in the new text |
| * @param limit offset immediately after the last character in the new text |
| * @return an MConstText object containing the characters and styles in the given range |
| */ |
| public MText extractWritable(int start, int limit) |
| { |
| MText text = new StyledText(); |
| text.replace(0, 0, this, start, limit); |
| text.resetDamagedRange(); |
| return text; |
| } |
| |
| //-------------------------------------------------------- |
| // size/capacity |
| //-------------------------------------------------------- |
| /** |
| * Return the length of the MConstText object. The length is the number of characters in the text. |
| * @return the length of the MConstText object |
| */ |
| public int length() |
| { |
| return fCharBuffer.length(); |
| } |
| |
| /** |
| * Create a <code>CharacterIterator</code> over the range [<code>start</code>, <code>limit</code>). |
| * @param start the beginning of the iterator's range |
| * @param limit the limit of the iterator's range |
| * @return a valid <code>CharacterIterator</code> over the specified range |
| * @see java.text.CharacterIterator |
| */ |
| public CharacterIterator createCharacterIterator(int start, int limit) |
| { |
| return fCharBuffer.createCharacterIterator(start, limit); |
| } |
| |
| //-------------------------------------------------------- |
| // character styles |
| //-------------------------------------------------------- |
| |
| /** |
| * Return the index of the first character in the character style run |
| * containing pos. All characters in a style run have the same character |
| * style. |
| * @return the style at offset <code>pos</code> |
| */ |
| public int characterStyleStart(int pos) { |
| |
| checkPos(pos, LESS_THAN_LENGTH); |
| return fStyleBuffer.styleStart(pos); |
| } |
| |
| /** |
| * Return the index after the last character in the character style run |
| * containing pos. All characters in a style run have the same character |
| * style. |
| * @return the style at offset <code>pos</code> |
| */ |
| public int characterStyleLimit(int pos) { |
| |
| checkPos(pos, NOT_GREATER_THAN_LENGTH); |
| return fStyleBuffer.styleLimit(pos); |
| } |
| |
| /** |
| * Return the style applied to the character at offset <code>pos</code>. |
| * @param pos a valid offset into the text |
| * @return the style at offset <code>pos</code> |
| */ |
| public AttributeMap characterStyleAt(int pos) |
| { |
| checkPos(pos, NOT_GREATER_THAN_LENGTH); |
| return fStyleBuffer.styleAt(pos); |
| } |
| |
| //-------------------------------------------------------- |
| // paragraph boundaries and styles |
| //-------------------------------------------------------- |
| /** |
| * Return the start of the paragraph containing the character at offset <code>pos</code>. |
| * @param pos a valid offset into the text |
| * @return the start of the paragraph containing the character at offset <code>pos</code> |
| */ |
| public int paragraphStart(int pos) |
| { |
| checkPos(pos, NOT_GREATER_THAN_LENGTH); |
| return fParagraphBuffer.paragraphStart(pos); |
| } |
| |
| /** |
| * Return the limit of the paragraph containing the character at offset <code>pos</code>. |
| * @param pos a valid offset into the text |
| * @return the limit of the paragraph containing the character at offset <code>pos</code> |
| */ |
| public int paragraphLimit(int pos) |
| { |
| checkPos(pos, NOT_GREATER_THAN_LENGTH); |
| return fParagraphBuffer.paragraphLimit(pos); |
| } |
| |
| /** |
| * Return the paragraph style applied to the paragraph containing offset <code>pos</code>. |
| * @param pos a valid offset into the text |
| * @return the paragraph style in effect at <code>pos</code> |
| */ |
| public AttributeMap paragraphStyleAt(int pos) |
| { |
| checkPos(pos, NOT_GREATER_THAN_LENGTH); |
| return fParagraphBuffer.paragraphStyleAt(pos); |
| } |
| |
| /** |
| * Return the current time stamp. The time stamp is |
| * incremented whenever the contents of the MConstText changes. |
| * @return the current paragraph style time stamp |
| */ |
| public int getTimeStamp() { |
| |
| return fTimeStamp; |
| } |
| |
| //====================================================== |
| // MText INTERFACES |
| //====================================================== |
| //-------------------------------------------------------- |
| // character modfication functions |
| //-------------------------------------------------------- |
| |
| private void updateDamagedRange(int deleteStart, |
| int deleteLimit, |
| int insertLength) { |
| |
| fDamagedRange[0] = Math.min(fDamagedRange[0], deleteStart); |
| |
| if (fDamagedRange[1] >= deleteLimit) { |
| int lengthChange = insertLength - (deleteLimit-deleteStart); |
| fDamagedRange[1] += lengthChange; |
| } |
| else { |
| fDamagedRange[1] = deleteStart + insertLength; |
| } |
| } |
| |
| /** |
| * Replace the characters and styles in the range [<code>start</code>, <code>limit</code>) with the characters |
| * and styles in <code>srcText</code> in the range [<code>srcStart</code>, <code>srcLimit</code>). <code>srcText</code> is not |
| * modified. |
| * @param start the offset at which the replace operation begins |
| * @param limit the offset at which the replace operation ends. The character and style at |
| * <code>limit</code> is not modified. |
| * @param text the source for the new characters and styles |
| * @param srcStart the offset into <code>srcText</code> where new characters and styles will be obtained |
| * @param srcLimit the offset into <code>srcText</code> where the new characters and styles end |
| */ |
| public void replace(int start, int limit, MConstText text, int srcStart, int srcLimit) |
| { |
| if (text == this) { |
| text = new StyledText(text); |
| } |
| |
| if (start == limit && srcStart == srcLimit) { |
| return; |
| } |
| |
| checkStartLimit(start, limit); |
| |
| updateDamagedRange(start, limit, srcLimit-srcStart); |
| |
| fCharBuffer.replace(start, limit, text, srcStart, srcLimit); |
| fStyleBuffer.replace(start, limit, text, srcStart, srcLimit); |
| fParagraphBuffer.replace(start, limit, text, srcStart, srcLimit, fDamagedRange); |
| fTimeStamp += 1; |
| } |
| |
| /** |
| * Replace the characters and styles in the range [<code>start</code>, <code>limit</code>) with the characters |
| * and styles in <code>srcText</code>. <code>srcText</code> is not |
| * modified. |
| * @param start the offset at which the replace operation begins |
| * @param limit the offset at which the replace operation ends. The character and style at |
| * <code>limit</code> is not modified. |
| * @param text the source for the new characters and styles |
| */ |
| public void replace(int start, int limit, MConstText text) { |
| |
| replace(start, limit, text, 0, text.length()); |
| } |
| |
| /** |
| * Replace the characters in the range [<code>start</code>, <code>limit</code>) with the characters |
| * in <code>srcChars</code> in the range [<code>srcStart</code>, <code>srcLimit</code>). New characters take on the style |
| * <code>charsStyle</code>. |
| * <code>srcChars</code> is not modified. |
| * @param start the offset at which the replace operation begins |
| * @param limit the offset at which the replace operation ends. The character at |
| * <code>limit</code> is not modified. |
| * @param srcChars the source for the new characters |
| * @param srcStart the offset into <code>srcChars</code> where new characters will be obtained |
| * @param srcLimit the offset into <code>srcChars</code> where the new characters end |
| * @param charsStyle the style of the new characters |
| */ |
| public void replace(int start, int limit, char[] srcChars, int srcStart, int srcLimit, AttributeMap charsStyle) |
| { |
| checkStartLimit(start, limit); |
| |
| if (start == limit && srcStart == srcLimit) { |
| return; |
| } |
| |
| updateDamagedRange(start, limit, srcLimit-srcStart); |
| |
| fCharBuffer.replace(start, limit, srcChars, srcStart, srcLimit); |
| |
| replaceCharStylesWith(start, limit, start + (srcLimit-srcStart), charsStyle); |
| |
| fParagraphBuffer.deleteText(start, limit, fDamagedRange); |
| fParagraphBuffer.insertText(start, srcChars, srcStart, srcLimit); |
| |
| fTimeStamp += 1; |
| } |
| |
| private void replaceCharStylesWith(int start, int oldLimit, int newLimit, AttributeMap style) { |
| |
| if (start < oldLimit) { |
| fStyleBuffer.deleteText(start, oldLimit); |
| } |
| if (start < newLimit) { |
| if (forceModifier == null) { |
| forceModifier = new ForceModifier(); |
| } |
| forceModifier.setStyle(style); |
| fStyleBuffer.insertText(start, newLimit); |
| fStyleBuffer.modifyStyles(start, newLimit, forceModifier, null); |
| } |
| } |
| |
| /** |
| * Replace the characters in the range [<code>start</code>, <code>limit</code>) with the character <code>srcChar</code>. |
| * The new character takes on the style <code>charStyle</code> |
| * @param start the offset at which the replace operation begins |
| * @param limit the offset at which the replace operation ends. The character at |
| * <code>limit</code> is not modified. |
| * @param srcChar the new character |
| * @param charStyle the style of the new character |
| */ |
| public void replace(int start, int limit, char srcChar, AttributeMap charStyle) |
| { |
| checkStartLimit(start, limit); |
| |
| updateDamagedRange(start, limit, 1); |
| |
| fCharBuffer.replace(start, limit, srcChar); |
| |
| replaceCharStylesWith(start, limit, start + 1, charStyle); |
| |
| if (start < limit) { |
| fParagraphBuffer.deleteText(start, limit, fDamagedRange); |
| } |
| |
| fParagraphBuffer.insertText(start, srcChar); |
| |
| fTimeStamp += 1; |
| } |
| |
| /** |
| * Replace the entire contents of this MText (both characters and styles) with |
| * the contents of <code>srcText</code>. |
| * @param srcText the source for the new characters and styles |
| */ |
| public void replaceAll(MConstText srcText) |
| { |
| replace(0, length(), srcText, 0, srcText.length()); |
| } |
| |
| /** |
| * Insert the contents of <code>srcText</code> (both characters and styles) into this |
| * MText at the position specified by <code>pos</code>. |
| * @param pos The character offset where the new text is to be inserted. |
| * @param srcText The text to insert. |
| */ |
| public void insert(int pos, MConstText srcText) |
| { |
| replace(pos, pos, srcText, 0, srcText.length()); |
| } |
| |
| /** |
| * Append the contents of <code>srcText</code> (both characters and styles) to the |
| * end of this MText. |
| * @param srcText The text to append. |
| */ |
| public void append(MConstText srcText) |
| { |
| replace(length(), length(), srcText, 0, srcText.length()); |
| } |
| |
| /** |
| * Delete the specified range of characters (and styles). |
| * @param start Offset of the first character to delete. |
| * @param limit Offset of the first character after the range to delete. |
| */ |
| public void remove(int start, int limit) |
| { |
| replace(start, limit, (char[])null, 0, 0, AttributeMap.EMPTY_ATTRIBUTE_MAP); |
| } |
| |
| /** |
| * Delete all characters and styles. Always increments time stamp. |
| */ |
| public void remove() |
| { |
| // rather than going through replace(), just reinitialize the StyledText, |
| // letting the old data structures fall on the floor |
| fCharBuffer = new CharBuffer(); |
| fStyleBuffer = new StyleBuffer(this, AttributeMap.EMPTY_ATTRIBUTE_MAP); |
| fParagraphBuffer = new ParagraphBuffer(fCharBuffer); |
| fTimeStamp += 1; |
| fDamagedRange[0] = fDamagedRange[1] = 0; |
| } |
| |
| //-------------------------------------------------------- |
| // storage management |
| //-------------------------------------------------------- |
| |
| /** |
| * Minimize the amount of memory used by the MText object. |
| */ |
| public void compress() { |
| |
| fCharBuffer.compress(); |
| fStyleBuffer.compress(); |
| fParagraphBuffer.compress(); |
| } |
| |
| //-------------------------------------------------------- |
| // style modification |
| //-------------------------------------------------------- |
| |
| /** |
| * Set the style of all characters in the MText object to |
| * <code>AttributeMap.EMPTY_ATTRIBUTE_MAP</code>. |
| */ |
| public void removeCharacterStyles() { |
| |
| fStyleBuffer = new StyleBuffer(this, AttributeMap.EMPTY_ATTRIBUTE_MAP); |
| fTimeStamp += 1; |
| fDamagedRange[0] = 0; |
| fDamagedRange[1] = length(); |
| } |
| |
| /** |
| * Invoke the given modifier on all character styles from start to limit. |
| * @param modifier the modifier to apply to the range. |
| * @param start the start of the range of text to modify. |
| * @param limit the limit of the range of text to modify. |
| */ |
| public void modifyCharacterStyles(int start, int limit, StyleModifier modifier) { |
| |
| checkStartLimit(start, limit); |
| boolean modified = fStyleBuffer.modifyStyles(start, |
| limit, |
| modifier, |
| fDamagedRange); |
| if (modified) { |
| fTimeStamp += 1; |
| } |
| } |
| |
| /** |
| * Invoke the given modifier on all paragraph styles in paragraphs |
| * containing characters in the range [start, limit). |
| * @param modifier the modifier to apply to the range. |
| * @param start the start of the range of text to modify. |
| * @param limit the limit of the range of text to modify. |
| */ |
| public void modifyParagraphStyles(int start, int limit, StyleModifier modifier) { |
| |
| checkStartLimit(start, limit); |
| boolean modified = fParagraphBuffer.modifyParagraphStyles(start, |
| limit, |
| modifier, |
| fDamagedRange); |
| if (modified) { |
| fTimeStamp += 1; |
| } |
| } |
| |
| /** |
| * Reset the damaged range to an empty interval, and begin accumulating the damaged |
| * range. The damaged range includes every index where a character, character style, |
| * or paragraph style has changed. |
| * @see #damagedRangeStart |
| * @see #damagedRangeLimit |
| */ |
| public void resetDamagedRange() { |
| |
| fDamagedRange[0] = Integer.MAX_VALUE; |
| fDamagedRange[1] = Integer.MIN_VALUE; |
| } |
| |
| /** |
| * Return the start of the damaged range. |
| * If the start is |
| * <code>Integer.MAX_VALUE</code> and the limit is |
| * <code>Integer.MIN_VALUE</code>, then the damaged range |
| * is empty. |
| * @return the start of the damaged range |
| * @see #damagedRangeLimit |
| * @see #resetDamagedRange |
| */ |
| public int damagedRangeStart() { |
| |
| return fDamagedRange[0]; |
| } |
| |
| /** |
| * Return the limit of the damaged range. |
| * If the start is |
| * <code>Integer.MAX_VALUE</code> and the limit is |
| * <code>Integer.MIN_VALUE</code>, then the damaged range |
| * is empty. |
| * @return the limit of the damaged range |
| * @see #damagedRangeStart |
| * @see #resetDamagedRange |
| */ |
| public int damagedRangeLimit() { |
| |
| return fDamagedRange[1]; |
| } |
| |
| public String toString() |
| { |
| String result =""; |
| for (int i = 0; i < length(); i++) { |
| result += at(i); |
| } |
| return result; |
| } |
| |
| //====================================================== |
| // IMPLEMENTATION |
| //====================================================== |
| |
| /* check a range to see if it is well formed and within the bounds of the text */ |
| private void checkStartLimit(int start, int limit) |
| { |
| if (start > limit) { |
| //System.out.println("Start is less than limit. start:"+start+"; limit:"+limit); |
| throw new IllegalArgumentException("Start is greater than limit. start:"+start+"; limit:"+limit); |
| } |
| |
| if (start < 0) { |
| //System.out.println("Start is negative. start:"+start); |
| throw new IllegalArgumentException("Start is negative. start:"+start); |
| } |
| |
| if (limit > length()) { |
| //System.out.println("Limit is greater than length. limit:"+limit); |
| throw new IllegalArgumentException("Limit is greater than length. limit:"+limit); |
| } |
| } |
| |
| private static final boolean LESS_THAN_LENGTH = false; |
| private static final boolean NOT_GREATER_THAN_LENGTH = true; |
| |
| private void checkPos(int pos, boolean endAllowed) { |
| |
| int lastValidPos = length(); |
| if (endAllowed == LESS_THAN_LENGTH) { |
| --lastValidPos; |
| } |
| |
| if (pos < 0 || pos > lastValidPos) { |
| throw new IllegalArgumentException("Position is out of range."); |
| } |
| } |
| } |
