1002 lines
35 KiB
Java
1002 lines
35 KiB
Java
/* 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
|
|
&& dir != Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|