| /* Bidi.java -- Bidirectional Algorithm implementation |
| Copyright (C) 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.text; |
| |
| import java.awt.font.NumericShaper; |
| import java.awt.font.TextAttribute; |
| import java.util.ArrayList; |
| |
| |
| /** |
| * Bidirectional Algorithm implementation. |
| * |
| * The full algorithm is |
| * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard |
| * Annex #9: The Bidirectional Algorithm</a>. |
| * |
| * @since 1.4 |
| */ |
| public final class Bidi |
| { |
| /** |
| * This indicates that a strongly directional character in the text should |
| * set the initial direction, but if no such character is found, then the |
| * initial direction will be left-to-right. |
| */ |
| public static final int DIRECTION_DEFAULT_LEFT_TO_RIGHT = -2; |
| |
| /** |
| * This indicates that a strongly directional character in the text should |
| * set the initial direction, but if no such character is found, then the |
| * initial direction will be right-to-left. |
| */ |
| public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = -1; |
| |
| /** |
| * This indicates that the initial direction should be left-to-right. |
| */ |
| public static final int DIRECTION_LEFT_TO_RIGHT = 0; |
| |
| /** |
| * This indicates that the initial direction should be right-to-left. |
| */ |
| public static final int DIRECTION_RIGHT_TO_LEFT = 1; |
| |
| // Flags used when computing the result. |
| private static final int LTOR = 1 << DIRECTION_LEFT_TO_RIGHT; |
| private static final int RTOL = 1 << DIRECTION_RIGHT_TO_LEFT; |
| |
| // The text we are examining, and the starting offset. |
| // If we had a better way to handle createLineBidi, we wouldn't |
| // need this at all -- which for the String case would be an |
| // efficiency win. |
| private char[] text; |
| private int textOffset; |
| // The embeddings corresponding to the text, and the starting offset. |
| private byte[] embeddings; |
| private int embeddingOffset; |
| // The length of the text (and embeddings) to use. |
| private int length; |
| // The flags. |
| private int flags; |
| |
| // All instance fields following this point are initialized |
| // during analysis. Fields before this must be set by the constructor. |
| |
| // The initial embedding level. |
| private int baseEmbedding; |
| // The type of each character in the text. |
| private byte[] types; |
| // The levels we compute. |
| private byte[] levels; |
| |
| // A list of indices where a formatting code was found. These |
| // are indicies into the original text -- not into the text after |
| // the codes have been removed. |
| private ArrayList formatterIndices; |
| |
| // Indices of the starts of runs in the text. |
| private int[] runs; |
| |
| // A convenience field where we keep track of what kinds of runs |
| // we've seen. |
| private int resultFlags; |
| |
| /** |
| * Create a new Bidi object given an attributed character iterator. |
| * This constructor will examine various attributes of the text: |
| * <ul> |
| * <li> {@link TextAttribute#RUN_DIRECTION} is used to determine the |
| * paragraph's base embedding level. This constructor will recognize |
| * either {@link TextAttribute#RUN_DIRECTION_LTR} or |
| * {@link TextAttribute#RUN_DIRECTION_RTL}. If neither is given, |
| * {@link #DIRECTION_DEFAULT_LEFT_TO_RIGHT} is assumed. |
| * </li> |
| * |
| * <li> If {@link TextAttribute#NUMERIC_SHAPING} is seen, then numeric |
| * shaping will be done before the Bidi algorithm is run. |
| * </li> |
| * |
| * <li> If {@link TextAttribute#BIDI_EMBEDDING} is seen on a given |
| * character, then the value of this attribute will be used as an |
| * embedding level override. |
| * </li> |
| * </ul> |
| * @param iter the attributed character iterator to use |
| */ |
| public Bidi(AttributedCharacterIterator iter) |
| { |
| // If set, this attribute should be set on all characters. |
| // We don't check this (should we?) but we do assume that we |
| // can simply examine the first character. |
| Object val = iter.getAttribute(TextAttribute.RUN_DIRECTION); |
| if (val == TextAttribute.RUN_DIRECTION_LTR) |
| this.flags = DIRECTION_LEFT_TO_RIGHT; |
| else if (val == TextAttribute.RUN_DIRECTION_RTL) |
| this.flags = DIRECTION_RIGHT_TO_LEFT; |
| else |
| this.flags = DIRECTION_DEFAULT_LEFT_TO_RIGHT; |
| |
| // Likewise this attribute should be specified on the whole text. |
| // We read it here and then, if it is set, we apply the numeric shaper |
| // to the text before processing it. |
| NumericShaper shaper = null; |
| val = iter.getAttribute(TextAttribute.NUMERIC_SHAPING); |
| if (val instanceof NumericShaper) |
| shaper = (NumericShaper) val; |
| |
| char[] text = new char[iter.getEndIndex() - iter.getBeginIndex()]; |
| this.embeddings = new byte[this.text.length]; |
| this.embeddingOffset = 0; |
| this.length = text.length; |
| for (int i = 0; i < this.text.length; ++i) |
| { |
| this.text[i] = iter.current(); |
| |
| val = iter.getAttribute(TextAttribute.BIDI_EMBEDDING); |
| if (val instanceof Integer) |
| { |
| int ival = ((Integer) val).intValue(); |
| byte bval; |
| if (ival < -62 || ival > 62) |
| bval = 0; |
| else |
| bval = (byte) ival; |
| this.embeddings[i] = bval; |
| } |
| } |
| |
| // Invoke the numeric shaper, if specified. |
| if (shaper != null) |
| shaper.shape(this.text, 0, this.length); |
| |
| runBidi(); |
| } |
| |
| /** |
| * Create a new Bidi object with the indicated text and, possibly, explicit |
| * embedding settings. |
| * |
| * If the embeddings array is null, it is ignored. Otherwise it is taken to |
| * be explicit embedding settings corresponding to the text. Positive values |
| * from 1 to 61 are embedding levels, and negative values from -1 to -61 are |
| * embedding overrides. (FIXME: not at all clear what this really means.) |
| * |
| * @param text the text to use |
| * @param offset the offset of the first character of the text |
| * @param embeddings the explicit embeddings, or null if there are none |
| * @param embedOffset the offset of the first embedding value to use |
| * @param length the length of both the text and the embeddings |
| * @param flags a flag indicating the base embedding direction |
| */ |
| public Bidi(char[] text, int offset, byte[] embeddings, int embedOffset, |
| int length, int flags) |
| { |
| if (flags != DIRECTION_DEFAULT_LEFT_TO_RIGHT |
| && flags != DIRECTION_DEFAULT_RIGHT_TO_LEFT |
| && flags != DIRECTION_LEFT_TO_RIGHT |
| && flags != DIRECTION_RIGHT_TO_LEFT) |
| throw new IllegalArgumentException("unrecognized 'flags' argument: " |
| + flags); |
| this.text = text; |
| this.textOffset = offset; |
| this.embeddings = embeddings; |
| this.embeddingOffset = embedOffset; |
| this.length = length; |
| this.flags = flags; |
| |
| runBidi(); |
| } |
| |
| /** |
| * Create a new Bidi object using the contents of the given String |
| * as the text. |
| * @param text the text to use |
| * @param flags a flag indicating the base embedding direction |
| */ |
| public Bidi(String text, int flags) |
| { |
| if (flags != DIRECTION_DEFAULT_LEFT_TO_RIGHT |
| && flags != DIRECTION_DEFAULT_RIGHT_TO_LEFT |
| && flags != DIRECTION_LEFT_TO_RIGHT |
| && flags != DIRECTION_RIGHT_TO_LEFT) |
| throw new IllegalArgumentException("unrecognized 'flags' argument: " |
| + flags); |
| |
| // This is inefficient, but it isn't clear whether it matters. |
| // If it does we can change our implementation a bit to allow either |
| // a String or a char[]. |
| this.text = text.toCharArray(); |
| this.textOffset = 0; |
| this.embeddings = null; |
| this.embeddingOffset = 0; |
| this.length = text.length(); |
| this.flags = flags; |
| |
| runBidi(); |
| } |
| |
| /** |
| * Implementation function which computes the initial type of |
| * each character in the input. |
| */ |
| private void computeTypes() |
| { |
| types = new byte[length]; |
| for (int i = 0; i < length; ++i) |
| types[i] = Character.getDirectionality(text[textOffset + i]); |
| } |
| |
| /** |
| * An internal function which implements rules P2 and P3. |
| * This computes the base embedding level. |
| * @return the paragraph's base embedding level |
| */ |
| private int computeParagraphEmbeddingLevel() |
| { |
| // First check to see if the user supplied a directionality override. |
| if (flags == DIRECTION_LEFT_TO_RIGHT |
| || flags == DIRECTION_RIGHT_TO_LEFT) |
| return flags; |
| |
| // This implements rules P2 and P3. |
| // (Note that we don't need P1, as the user supplies |
| // a paragraph.) |
| for (int i = 0; i < length; ++i) |
| { |
| int dir = types[i]; |
| if (dir == Character.DIRECTIONALITY_LEFT_TO_RIGHT) |
| return DIRECTION_LEFT_TO_RIGHT; |
| if (dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT |
| || dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT) |
| return DIRECTION_RIGHT_TO_LEFT; |
| } |
| return (flags == DIRECTION_DEFAULT_LEFT_TO_RIGHT |
| ? DIRECTION_LEFT_TO_RIGHT |
| : DIRECTION_RIGHT_TO_LEFT); |
| } |
| |
| /** |
| * An internal function which implements rules X1 through X9. |
| * This computes the initial levels for the text, handling |
| * explicit overrides and embeddings. |
| */ |
| private void computeExplicitLevels() |
| { |
| levels = new byte[length]; |
| byte currentEmbedding = (byte) baseEmbedding; |
| // The directional override is a Character directionality |
| // constant. -1 means there is no override. |
| byte directionalOverride = -1; |
| // The stack of pushed embeddings, and the stack pointer. |
| // Note that because the direction is inherent in the depth, |
| // and because we have a bit left over in a byte, we can encode |
| // the override, if any, directly in this value on the stack. |
| final int MAX_DEPTH = 62; |
| byte[] embeddingStack = new byte[MAX_DEPTH]; |
| int sp = 0; |
| |
| for (int i = 0; i < length; ++i) |
| { |
| // If we see an explicit embedding, we use that, even if |
| // the current character is itself a directional override. |
| if (embeddings != null && embeddings[embeddingOffset + i] != 0) |
| { |
| // It isn't at all clear what we're supposed to do here. |
| // What does a negative value really mean? |
| // Should we push on the embedding stack here? |
| currentEmbedding = embeddings[embeddingOffset + i]; |
| if (currentEmbedding < 0) |
| { |
| currentEmbedding = (byte) -currentEmbedding; |
| directionalOverride |
| = (((currentEmbedding % 2) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| } |
| else |
| directionalOverride = -1; |
| continue; |
| } |
| // No explicit embedding. |
| boolean isLtoR = false; |
| boolean isSpecial = true; |
| switch (types[i]) |
| { |
| case Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: |
| case Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: |
| isLtoR = true; |
| // Fall through. |
| case Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: |
| case Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: |
| { |
| byte newEmbedding; |
| if (isLtoR) |
| { |
| // Least greater even. |
| newEmbedding = (byte) ((currentEmbedding & ~1) + 2); |
| } |
| else |
| { |
| // Least greater odd. |
| newEmbedding = (byte) ((currentEmbedding + 1) | 1); |
| } |
| // FIXME: we don't properly handle invalid pushes. |
| if (newEmbedding < MAX_DEPTH) |
| { |
| // The new level is valid. Push the old value. |
| // See above for a comment on the encoding here. |
| if (directionalOverride != -1) |
| currentEmbedding |= Byte.MIN_VALUE; |
| embeddingStack[sp++] = currentEmbedding; |
| currentEmbedding = newEmbedding; |
| if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE) |
| directionalOverride = Character.DIRECTIONALITY_LEFT_TO_RIGHT; |
| else if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE) |
| directionalOverride = Character.DIRECTIONALITY_RIGHT_TO_LEFT; |
| else |
| directionalOverride = -1; |
| } |
| } |
| break; |
| case Character.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: |
| { |
| // FIXME: we don't properly handle a pop with a corresponding |
| // invalid push. |
| if (sp == 0) |
| { |
| // We saw a pop without a push. Just ignore it. |
| break; |
| } |
| byte newEmbedding = embeddingStack[--sp]; |
| currentEmbedding = (byte) (newEmbedding & 0x7f); |
| if (newEmbedding < 0) |
| directionalOverride |
| = (((newEmbedding & 1) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| else |
| directionalOverride = -1; |
| } |
| break; |
| default: |
| isSpecial = false; |
| break; |
| } |
| levels[i] = currentEmbedding; |
| if (isSpecial) |
| { |
| // Mark this character for removal. |
| if (formatterIndices == null) |
| formatterIndices = new ArrayList(); |
| formatterIndices.add(Integer.valueOf(i)); |
| } |
| else if (directionalOverride != -1) |
| types[i] = directionalOverride; |
| } |
| |
| // Remove the formatting codes and update both the arrays |
| // and 'length'. It would be more efficient not to remove |
| // these codes, but it is also more complicated. Also, the |
| // Unicode algorithm reference does not properly describe |
| // how this is to be done -- from what I can tell, their suggestions |
| // in this area will not yield the correct results. |
| if (formatterIndices == null) |
| return; |
| int output = 0, input = 0; |
| final int size = formatterIndices.size(); |
| for (int i = 0; i <= size; ++i) |
| { |
| int nextFmt; |
| if (i == size) |
| nextFmt = length; |
| else |
| nextFmt = ((Integer) formatterIndices.get(i)).intValue(); |
| // Non-formatter codes are from 'input' to 'nextFmt'. |
| int len = nextFmt - input; |
| System.arraycopy(levels, input, levels, output, len); |
| System.arraycopy(types, input, types, output, len); |
| output += len; |
| input = nextFmt + 1; |
| } |
| length -= formatterIndices.size(); |
| } |
| |
| /** |
| * An internal function to compute the boundaries of runs |
| * in the text. It isn't strictly necessary to do this, but |
| * it lets us write some following passes in a less complicated |
| * way. Also it lets us efficiently implement some of the public |
| * methods. A run is simply a sequence of characters at the |
| * same level. |
| */ |
| private void computeRuns() |
| { |
| int runCount = 0; |
| int currentEmbedding = baseEmbedding; |
| for (int i = 0; i < length; ++i) |
| { |
| if (levels[i] != currentEmbedding) |
| { |
| currentEmbedding = levels[i]; |
| ++runCount; |
| } |
| } |
| |
| // This may be called multiple times. If so, and if |
| // the number of runs has not changed, then don't bother |
| // allocating a new array. |
| if (runs == null || runs.length != runCount + 1) |
| runs = new int[runCount + 1]; |
| int where = 0; |
| int lastRunStart = 0; |
| currentEmbedding = baseEmbedding; |
| for (int i = 0; i < length; ++i) |
| { |
| if (levels[i] != currentEmbedding) |
| { |
| runs[where++] = lastRunStart; |
| lastRunStart = i; |
| currentEmbedding = levels[i]; |
| } |
| } |
| runs[where++] = lastRunStart; |
| } |
| |
| /** |
| * An internal method to resolve weak types. This implements |
| * rules W1 through W7. |
| */ |
| private void resolveWeakTypes() |
| { |
| final int runCount = getRunCount(); |
| |
| int previousLevel = baseEmbedding; |
| for (int run = 0; run < runCount; ++run) |
| { |
| int start = getRunStart(run); |
| int end = getRunLimit(run); |
| int level = getRunLevel(run); |
| |
| // These are the names used in the Bidi algorithm. |
| byte sor = (((Math.max(previousLevel, level) % 2) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| int nextLevel; |
| if (run == runCount - 1) |
| nextLevel = baseEmbedding; |
| else |
| nextLevel = getRunLevel(run + 1); |
| byte eor = (((Math.max(level, nextLevel) % 2) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| |
| byte prevType = sor; |
| byte prevStrongType = sor; |
| for (int i = start; i < end; ++i) |
| { |
| final byte nextType = (i == end - 1) ? eor : types[i + 1]; |
| |
| // Rule W1: change NSM to the prevailing direction. |
| if (types[i] == Character.DIRECTIONALITY_NONSPACING_MARK) |
| types[i] = prevType; |
| else |
| prevType = types[i]; |
| |
| // Rule W2: change EN to AN in some cases. |
| if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| { |
| if (prevStrongType == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC) |
| types[i] = Character.DIRECTIONALITY_ARABIC_NUMBER; |
| } |
| else if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| || types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT |
| || types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC) |
| prevStrongType = types[i]; |
| |
| // Rule W3: change AL to R. |
| if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC) |
| types[i] = Character.DIRECTIONALITY_RIGHT_TO_LEFT; |
| |
| // Rule W4: handle separators between two numbers. |
| if (prevType == Character.DIRECTIONALITY_EUROPEAN_NUMBER |
| && nextType == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| { |
| if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR |
| || types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR) |
| types[i] = nextType; |
| } |
| else if (prevType == Character.DIRECTIONALITY_ARABIC_NUMBER |
| && nextType == Character.DIRECTIONALITY_ARABIC_NUMBER |
| && types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR) |
| types[i] = nextType; |
| |
| // Rule W5: change a sequence of european terminators to |
| // european numbers, if they are adjacent to european numbers. |
| // We also include BN characters in this. |
| if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR |
| || types[i] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL) |
| { |
| if (prevType == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| types[i] = prevType; |
| else |
| { |
| // Look ahead to see if there is an EN terminating this |
| // sequence of ETs. |
| int j = i + 1; |
| while (j < end |
| && (types[j] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR |
| || types[j] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL)) |
| ++j; |
| if (j < end |
| && types[j] == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| { |
| // Change them all to EN now. |
| for (int k = i; k < j; ++k) |
| types[k] = Character.DIRECTIONALITY_EUROPEAN_NUMBER; |
| } |
| } |
| } |
| |
| // Rule W6: separators and terminators change to ON. |
| // Again we include BN. |
| if (types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR |
| || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR |
| || types[i] == Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR |
| || types[i] == Character.DIRECTIONALITY_BOUNDARY_NEUTRAL) |
| types[i] = Character.DIRECTIONALITY_OTHER_NEUTRALS; |
| |
| // Rule W7: change european number types. |
| if (prevStrongType == Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| && types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| types[i] = prevStrongType; |
| } |
| |
| previousLevel = level; |
| } |
| } |
| |
| /** |
| * An internal method to resolve neutral types. This implements |
| * rules N1 and N2. |
| */ |
| private void resolveNeutralTypes() |
| { |
| // This implements rules N1 and N2. |
| final int runCount = getRunCount(); |
| |
| int previousLevel = baseEmbedding; |
| for (int run = 0; run < runCount; ++run) |
| { |
| int start = getRunStart(run); |
| int end = getRunLimit(run); |
| int level = getRunLevel(run); |
| |
| byte embeddingDirection |
| = (((level % 2) == 0) ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| // These are the names used in the Bidi algorithm. |
| byte sor = (((Math.max(previousLevel, level) % 2) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| int nextLevel; |
| if (run == runCount - 1) |
| nextLevel = baseEmbedding; |
| else |
| nextLevel = getRunLevel(run + 1); |
| byte eor = (((Math.max(level, nextLevel) % 2) == 0) |
| ? Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| : Character.DIRECTIONALITY_RIGHT_TO_LEFT); |
| |
| byte prevStrong = sor; |
| int neutralStart = -1; |
| for (int i = start; i <= end; ++i) |
| { |
| byte newStrong = -1; |
| byte thisType = i == end ? eor : types[i]; |
| switch (thisType) |
| { |
| case Character.DIRECTIONALITY_LEFT_TO_RIGHT: |
| newStrong = Character.DIRECTIONALITY_LEFT_TO_RIGHT; |
| break; |
| case Character.DIRECTIONALITY_RIGHT_TO_LEFT: |
| case Character.DIRECTIONALITY_ARABIC_NUMBER: |
| case Character.DIRECTIONALITY_EUROPEAN_NUMBER: |
| newStrong = Character.DIRECTIONALITY_RIGHT_TO_LEFT; |
| break; |
| case Character.DIRECTIONALITY_BOUNDARY_NEUTRAL: |
| case Character.DIRECTIONALITY_OTHER_NEUTRALS: |
| case Character.DIRECTIONALITY_SEGMENT_SEPARATOR: |
| case Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR: |
| case Character.DIRECTIONALITY_WHITESPACE: |
| if (neutralStart == -1) |
| neutralStart = i; |
| break; |
| } |
| // If we see a strong character, update all the neutrals. |
| if (newStrong != -1) |
| { |
| if (neutralStart != -1) |
| { |
| byte override = (prevStrong == newStrong |
| ? prevStrong |
| : embeddingDirection); |
| for (int j = neutralStart; j < i; ++j) |
| types[j] = override; |
| } |
| prevStrong = newStrong; |
| neutralStart = -1; |
| } |
| } |
| |
| previousLevel = level; |
| } |
| } |
| |
| /** |
| * An internal method to resolve implicit levels. |
| * This implements rules I1 and I2. |
| */ |
| private void resolveImplicitLevels() |
| { |
| // This implements rules I1 and I2. |
| for (int i = 0; i < length; ++i) |
| { |
| if ((levels[i] & 1) == 0) |
| { |
| if (types[i] == Character.DIRECTIONALITY_RIGHT_TO_LEFT) |
| ++levels[i]; |
| else if (types[i] == Character.DIRECTIONALITY_ARABIC_NUMBER |
| || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| levels[i] += 2; |
| } |
| else |
| { |
| if (types[i] == Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| || types[i] == Character.DIRECTIONALITY_ARABIC_NUMBER |
| || types[i] == Character.DIRECTIONALITY_EUROPEAN_NUMBER) |
| ++levels[i]; |
| } |
| |
| // Update the result flags. |
| resultFlags |= 1 << (levels[i] & 1); |
| } |
| // One final update of the result flags, using the base level. |
| resultFlags |= 1 << baseEmbedding; |
| } |
| |
| /** |
| * This reinserts the formatting codes that we removed early on. |
| * Actually it does not insert formatting codes per se, but rather |
| * simply inserts new levels at the appropriate locations in the |
| * 'levels' array. |
| */ |
| private void reinsertFormattingCodes() |
| { |
| if (formatterIndices == null) |
| return; |
| int input = length; |
| int output = levels.length; |
| // Process from the end as we are copying the array over itself here. |
| for (int index = formatterIndices.size() - 1; index >= 0; --index) |
| { |
| int nextFmt = ((Integer) formatterIndices.get(index)).intValue(); |
| |
| // nextFmt points to a location in the original array. So, |
| // nextFmt+1 is the target of our copying. output is the location |
| // to which we last copied, thus we can derive the length of the |
| // copy from it. |
| int len = output - nextFmt - 1; |
| output = nextFmt; |
| input -= len; |
| // Note that we no longer need 'types' at this point, so we |
| // only edit 'levels'. |
| if (nextFmt + 1 < levels.length) |
| System.arraycopy(levels, input, levels, nextFmt + 1, len); |
| |
| // Now set the level at the reinsertion point. |
| int rightLevel; |
| if (output == levels.length - 1) |
| rightLevel = baseEmbedding; |
| else |
| rightLevel = levels[output + 1]; |
| int leftLevel; |
| if (input == 0) |
| leftLevel = baseEmbedding; |
| else |
| leftLevel = levels[input]; |
| levels[output] = (byte) Math.max(leftLevel, rightLevel); |
| } |
| length = levels.length; |
| } |
| |
| /** |
| * This is the main internal entry point. After a constructor |
| * has initialized the appropriate local state, it will call |
| * this method to do all the work. |
| */ |
| private void runBidi() |
| { |
| computeTypes(); |
| baseEmbedding = computeParagraphEmbeddingLevel(); |
| computeExplicitLevels(); |
| computeRuns(); |
| resolveWeakTypes(); |
| resolveNeutralTypes(); |
| resolveImplicitLevels(); |
| // We're done with the types. Let the GC clean up. |
| types = null; |
| reinsertFormattingCodes(); |
| // After resolving the implicit levels, the number |
| // of runs may have changed. |
| computeRuns(); |
| } |
| |
| /** |
| * Return true if the paragraph base embedding is left-to-right, |
| * false otherwise. |
| */ |
| public boolean baseIsLeftToRight() |
| { |
| return baseEmbedding == DIRECTION_LEFT_TO_RIGHT; |
| } |
| |
| /** |
| * Create a new Bidi object for a single line of text, taken |
| * from the text used when creating the current Bidi object. |
| * @param start the index of the first character of the line |
| * @param end the index of the final character of the line |
| * @return a new Bidi object for the indicated line of text |
| */ |
| public Bidi createLineBidi(int start, int end) |
| { |
| // This isn't the most efficient implementation possible. |
| // This probably does not matter, so we choose simplicity instead. |
| int level = getLevelAt(start); |
| int flag = (((level % 2) == 0) |
| ? DIRECTION_LEFT_TO_RIGHT |
| : DIRECTION_RIGHT_TO_LEFT); |
| return new Bidi(text, textOffset + start, |
| embeddings, embeddingOffset + start, |
| end - start, flag); |
| } |
| |
| /** |
| * Return the base embedding level of the paragraph. |
| */ |
| public int getBaseLevel() |
| { |
| return baseEmbedding; |
| } |
| |
| /** |
| * Return the length of the paragraph, in characters. |
| */ |
| public int getLength() |
| { |
| return length; |
| } |
| |
| /** |
| * Return the level at the indicated character. If the |
| * supplied index is less than zero or greater than the length |
| * of the text, then the paragraph's base embedding level will |
| * be returned. |
| * @param offset the character to examine |
| * @return the level of that character |
| */ |
| public int getLevelAt(int offset) |
| { |
| if (offset < 0 || offset >= length) |
| return getBaseLevel(); |
| return levels[offset]; |
| } |
| |
| /** |
| * Return the number of runs in the result. A run is |
| * a sequence of characters at the same embedding level. |
| */ |
| public int getRunCount() |
| { |
| return runs.length; |
| } |
| |
| /** |
| * Return the level of the indicated run. |
| * @param which the run to examine |
| * @return the level of that run |
| */ |
| public int getRunLevel(int which) |
| { |
| return levels[runs[which]]; |
| } |
| |
| /** |
| * Return the index of the character just following the end |
| * of the indicated run. |
| * @param which the run to examine |
| * @return the index of the character after the final character |
| * of the run |
| */ |
| public int getRunLimit(int which) |
| { |
| if (which == runs.length - 1) |
| return length; |
| return runs[which + 1]; |
| } |
| |
| /** |
| * Return the index of the first character in the indicated run. |
| * @param which the run to examine |
| * @return the index of the first character of the run |
| */ |
| public int getRunStart(int which) |
| { |
| return runs[which]; |
| } |
| |
| /** |
| * Return true if the text is entirely left-to-right, and the |
| * base embedding is also left-to-right. |
| */ |
| public boolean isLeftToRight() |
| { |
| return resultFlags == LTOR; |
| } |
| |
| /** |
| * Return true if the text consists of mixed left-to-right and |
| * right-to-left runs, or if the text consists of one kind of run |
| * which differs from the base embedding direction. |
| */ |
| public boolean isMixed() |
| { |
| return resultFlags == (LTOR | RTOL); |
| } |
| |
| /** |
| * Return true if the text is entirely right-to-left, and the |
| * base embedding is also right-to-left. |
| */ |
| public boolean isRightToLeft() |
| { |
| return resultFlags == RTOL; |
| } |
| |
| /** |
| * Return a String describing the internal state of this object. |
| * This is only useful for debugging. |
| */ |
| public String toString() |
| { |
| return "Bidi Bidi Bidi I like you, Buck!"; |
| } |
| |
| /** |
| * Reorder objects according to the levels passed in. This implements |
| * reordering as defined by the Unicode bidirectional layout specification. |
| * The levels are integers from 0 to 62; even numbers represent left-to-right |
| * runs, and odd numbers represent right-to-left runs. |
| * |
| * @param levels the levels associated with each object |
| * @param levelOffset the index of the first level to use |
| * @param objs the objects to reorder according to the levels |
| * @param objOffset the index of the first object to use |
| * @param count the number of objects (and levels) to manipulate |
| */ |
| public static void reorderVisually(byte[] levels, int levelOffset, |
| Object[] objs, int objOffset, int count) |
| { |
| // We need a copy of the 'levels' array, as we are going to modify it. |
| // This is unfortunate but difficult to avoid. |
| byte[] levelCopy = new byte[count]; |
| // Do this explicitly so we can also find the maximum depth at the |
| // same time. |
| int max = 0; |
| int lowestOdd = 63; |
| for (int i = 0; i < count; ++i) |
| { |
| levelCopy[i] = levels[levelOffset + i]; |
| max = Math.max(levelCopy[i], max); |
| if (levelCopy[i] % 2 != 0) |
| lowestOdd = Math.min(lowestOdd, levelCopy[i]); |
| } |
| |
| // Reverse the runs starting with the deepest. |
| for (int depth = max; depth >= lowestOdd; --depth) |
| { |
| int start = 0; |
| while (start < count) |
| { |
| // Find the start of a run >= DEPTH. |
| while (start < count && levelCopy[start] < depth) |
| ++start; |
| if (start == count) |
| break; |
| // Find the end of the run. |
| int end = start + 1; |
| while (end < count && levelCopy[end] >= depth) |
| ++end; |
| |
| // Reverse this run. |
| for (int i = 0; i < (end - start) / 2; ++i) |
| { |
| byte tmpb = levelCopy[end - i - 1]; |
| levelCopy[end - i - 1] = levelCopy[start + i]; |
| levelCopy[start + i] = tmpb; |
| Object tmpo = objs[objOffset + end - i - 1]; |
| objs[objOffset + end - i - 1] = objs[objOffset + start + i]; |
| objs[objOffset + start + i] = tmpo; |
| } |
| |
| // Handle the next run. |
| start = end + 1; |
| } |
| } |
| } |
| |
| /** |
| * Returns false if all characters in the text between start and end |
| * are all left-to-right text. This implementation is just calls |
| * <code>Character.getDirectionality(char)</code> on all characters |
| * and makes sure all characters are either explicitly left-to-right |
| * or neutral in directionality (character types L, EN, ES, ET, AN, |
| * CS, S and WS). |
| */ |
| public static boolean requiresBidi(char[] text, int start, int end) |
| { |
| for (int i = start; i < end; i++) |
| { |
| byte dir = Character.getDirectionality(text[i]); |
| if (dir != Character.DIRECTIONALITY_LEFT_TO_RIGHT |
| && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER |
| && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR |
| && dir != Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR |
| && dir != Character.DIRECTIONALITY_ARABIC_NUMBER |
| && dir != Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR |
| && dir != Character.DIRECTIONALITY_SEGMENT_SEPARATOR |
| && dir != Character.DIRECTIONALITY_WHITESPACE) |
| return true; |
| } |
| |
| return false; |
| } |
| } |