* * Note: Libraries that perform a bidirectional algorithm and reorder strings * accordingly are sometimes called "Storage Layout Engines". ICU's Bidi and * shaping (ArabicShaping) classes can be used at the core of such "Storage * Layout Engines". * *
* * Some of the API methods provide access to "runs". Such a * "run" is defined as a sequence of characters that are at the same * embedding level after performing the Bidi algorithm. *
* *
Block Separator. For handling of
* paragraphs, see:
*
*
* Levels can be abstract values when used for the
* paraLevel and embeddingLevels
* arguments of setPara(); there:
*
embeddingLevels[]
* value indicates whether the using application is
* specifying the level of a character to override whatever the
* Bidi implementation would resolve it to.paraLevel can be set to the
* pseudo-level values LEVEL_DEFAULT_LTR
* and LEVEL_DEFAULT_RTL.The related constants are not real, valid level values.
* DEFAULT_XXX can be used to specify
* a default for the paragraph level for
* when the setPara() method
* shall determine it but there is no
* strongly typed character in the input.
*
* Note that the value for LEVEL_DEFAULT_LTR is even
* and the one for LEVEL_DEFAULT_RTL is odd,
* just like with normal LTR and RTL level values -
* these special values are designed that way. Also, the implementation
* assumes that MAX_EXPLICIT_LEVEL is odd.
*
*
* The basic assumptions are: *
*
*
* package com.ibm.icu.dev.test.bidi;
*
* import com.ibm.icu.text.Bidi;
* import com.ibm.icu.text.BidiRun;
*
* public class Sample {
*
* static final int styleNormal = 0;
* static final int styleSelected = 1;
* static final int styleBold = 2;
* static final int styleItalics = 4;
* static final int styleSuper=8;
* static final int styleSub = 16;
*
* static class StyleRun {
* int limit;
* int style;
*
* public StyleRun(int limit, int style) {
* this.limit = limit;
* this.style = style;
* }
* }
*
* static class Bounds {
* int start;
* int limit;
*
* public Bounds(int start, int limit) {
* this.start = start;
* this.limit = limit;
* }
* }
*
* static int getTextWidth(String text, int start, int limit,
* StyleRun[] styleRuns, int styleRunCount) {
* // simplistic way to compute the width
* return limit - start;
* }
*
* // set limit and StyleRun limit for a line
* // from text[start] and from styleRuns[styleRunStart]
* // using Bidi.getLogicalRun(...)
* // returns line width
* static int getLineBreak(String text, Bounds line, Bidi para,
* StyleRun styleRuns[], Bounds styleRun) {
* // dummy return
* return 0;
* }
*
* // render runs on a line sequentially, always from left to right
*
* // prepare rendering a new line
* static void startLine(byte textDirection, int lineWidth) {
* System.out.println();
* }
*
* // render a run of text and advance to the right by the run width
* // the text[start..limit-1] is always in logical order
* static void renderRun(String text, int start, int limit,
* byte textDirection, int style) {
* }
*
* // We could compute a cross-product
* // from the style runs with the directional runs
* // and then reorder it.
* // Instead, here we iterate over each run type
* // and render the intersections -
* // with shortcuts in simple (and common) cases.
* // renderParagraph() is the main function.
*
* // render a directional run with
* // (possibly) multiple style runs intersecting with it
* static void renderDirectionalRun(String text, int start, int limit,
* byte direction, StyleRun styleRuns[],
* int styleRunCount) {
* int i;
*
* // iterate over style runs
* if (direction == Bidi.LTR) {
* int styleLimit;
* for (i = 0; i < styleRunCount; ++i) {
* styleLimit = styleRuns[i].limit;
* if (start < styleLimit) {
* if (styleLimit > limit) {
* styleLimit = limit;
* }
* renderRun(text, start, styleLimit,
* direction, styleRuns[i].style);
* if (styleLimit == limit) {
* break;
* }
* start = styleLimit;
* }
* }
* } else {
* int styleStart;
*
* for (i = styleRunCount-1; i >= 0; --i) {
* if (i > 0) {
* styleStart = styleRuns[i-1].limit;
* } else {
* styleStart = 0;
* }
* if (limit >= styleStart) {
* if (styleStart < start) {
* styleStart = start;
* }
* renderRun(text, styleStart, limit, direction,
* styleRuns[i].style);
* if (styleStart == start) {
* break;
* }
* limit = styleStart;
* }
* }
* }
* }
*
* // the line object represents text[start..limit-1]
* static void renderLine(Bidi line, String text, int start, int limit,
* StyleRun styleRuns[], int styleRunCount) {
* byte direction = line.getDirection();
* if (direction != Bidi.MIXED) {
* // unidirectional
* if (styleRunCount <= 1) {
* renderRun(text, start, limit, direction, styleRuns[0].style);
* } else {
* renderDirectionalRun(text, start, limit, direction,
* styleRuns, styleRunCount);
* }
* } else {
* // mixed-directional
* int count, i;
* BidiRun run;
*
* try {
* count = line.countRuns();
* } catch (IllegalStateException e) {
* e.printStackTrace();
* return;
* }
* if (styleRunCount <= 1) {
* int style = styleRuns[0].style;
*
* // iterate over directional runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderRun(text, run.getStart(), run.getLimit(),
* run.getDirection(), style);
* }
* } else {
* // iterate over both directional and style runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderDirectionalRun(text, run.getStart(),
* run.getLimit(), run.getDirection(),
* styleRuns, styleRunCount);
* }
* }
* }
* }
*
* static void renderParagraph(String text, byte textDirection,
* StyleRun styleRuns[], int styleRunCount,
* int lineWidth) {
* int length = text.length();
* Bidi para = new Bidi();
* try {
* para.setPara(text,
* textDirection != 0 ? Bidi.LEVEL_DEFAULT_RTL
* : Bidi.LEVEL_DEFAULT_LTR,
* null);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* byte paraLevel = (byte)(1 & para.getParaLevel());
* StyleRun styleRun = new StyleRun(length, styleNormal);
*
* if (styleRuns == null || styleRunCount <= 0) {
* styleRuns = new StyleRun[1];
* styleRunCount = 1;
* styleRuns[0] = styleRun;
* }
* // assume styleRuns[styleRunCount-1].limit>=length
*
* int width = getTextWidth(text, 0, length, styleRuns, styleRunCount);
* if (width <= lineWidth) {
* // everything fits onto one line
*
* // prepare rendering a new line from either left or right
* startLine(paraLevel, width);
*
* renderLine(para, text, 0, length, styleRuns, styleRunCount);
* } else {
* // we need to render several lines
* Bidi line = new Bidi(length, 0);
* int start = 0, limit;
* int styleRunStart = 0, styleRunLimit;
*
* for (;;) {
* limit = length;
* styleRunLimit = styleRunCount;
* width = getLineBreak(text, new Bounds(start, limit),
* para, styleRuns,
* new Bounds(styleRunStart, styleRunLimit));
* try {
* line = para.setLine(start, limit);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* // prepare rendering a new line
* // from either left or right
* startLine(paraLevel, width);
*
* if (styleRunStart > 0) {
* int newRunCount = styleRuns.length - styleRunStart;
* StyleRun[] newRuns = new StyleRun[newRunCount];
* System.arraycopy(styleRuns, styleRunStart, newRuns, 0,
* newRunCount);
* renderLine(line, text, start, limit, newRuns,
* styleRunLimit - styleRunStart);
* } else {
* renderLine(line, text, start, limit, styleRuns,
* styleRunLimit - styleRunStart);
* }
* if (limit == length) {
* break;
* }
* start = limit;
* styleRunStart = styleRunLimit - 1;
* if (start >= styleRuns[styleRunStart].limit) {
* ++styleRunStart;
* }
* }
* }
* }
*
* public static void main(String[] args)
* {
* renderParagraph("Some Latin text...", Bidi.LTR, null, 0, 80);
* renderParagraph("Some Hebrew text...", Bidi.RTL, null, 0, 60);
* }
* }
*
*
*/
public class BidiBase {
class Point {
int pos; /* position in text */
int flag; /* flag for LRM/RLM, before/after */
}
class InsertPoints {
int size;
int confirmed;
Point[] points = new Point[0];
}
/** Paragraph level setting* * Constant indicating that the base direction depends on the first strong * directional character in the text according to the Unicode Bidirectional * Algorithm. If no strong directional character is present, * then set the paragraph level to 0 (left-to-right).
*
* If this value is used in conjunction with reordering modes
* REORDER_INVERSE_LIKE_DIRECT or
* REORDER_INVERSE_FOR_NUMBERS_SPECIAL, the text to reorder
* is assumed to be visual LTR, and the text after reordering is required
* to be the corresponding logical string with appropriate contextual
* direction. The direction of the result string will be RTL if either
* the righmost or leftmost strong character of the source text is RTL
* or Arabic Letter, the direction will be LTR otherwise.
*
* If reordering option OPTION_INSERT_MARKS is set, an RLM may
* be added at the beginning of the result string to ensure round trip
* (that the result string, when reordered back to visual, will produce
* the original source text).
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte INTERNAL_LEVEL_DEFAULT_LTR = (byte)0x7e;
/** Paragraph level setting
* * Constant indicating that the base direction depends on the first strong * directional character in the text according to the Unicode Bidirectional * Algorithm. If no strong directional character is present, * then set the paragraph level to 1 (right-to-left).
*
* If this value is used in conjunction with reordering modes
* REORDER_INVERSE_LIKE_DIRECT or
* REORDER_INVERSE_FOR_NUMBERS_SPECIAL, the text to reorder
* is assumed to be visual LTR, and the text after reordering is required
* to be the corresponding logical string with appropriate contextual
* direction. The direction of the result string will be RTL if either
* the righmost or leftmost strong character of the source text is RTL
* or Arabic Letter, or if the text contains no strong character;
* the direction will be LTR otherwise.
*
* If reordering option OPTION_INSERT_MARKS is set, an RLM may
* be added at the beginning of the result string to ensure round trip
* (that the result string, when reordered back to visual, will produce
* the original source text).
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte INTERNAL_LEVEL_DEFAULT_RTL = (byte)0x7f;
/**
* Maximum explicit embedding level.
* (The maximum resolved level can be up to MAX_EXPLICIT_LEVEL+1).
* @stable ICU 3.8
*/
public static final byte MAX_EXPLICIT_LEVEL = 61;
/**
* Bit flag for level input.
* Overrides directional properties.
* @stable ICU 3.8
*/
public static final byte INTERNAL_LEVEL_OVERRIDE = (byte)0x80;
/**
* Special value which can be returned by the mapping methods when a
* logical index has no corresponding visual index or vice-versa. This may
* happen for the logical-to-visual mapping of a Bidi control when option
* OPTION_REMOVE_CONTROLS is
* specified. This can also happen for the visual-to-logical mapping of a
* Bidi mark (LRM or RLM) inserted by option
* OPTION_INSERT_MARKS.
* @see #getVisualIndex
* @see #getVisualMap
* @see #getLogicalIndex
* @see #getLogicalMap
* @see #OPTION_INSERT_MARKS
* @see #OPTION_REMOVE_CONTROLS
* @stable ICU 3.8
*/
public static final int MAP_NOWHERE = -1;
/**
* Mixed-directional text.
* @stable ICU 3.8
*/
public static final byte MIXED = 2;
/**
* option bit for writeReordered():
* replace characters with the "mirrored" property in RTL runs
* by their mirror-image mappings
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short DO_MIRRORING = 2;
/** Reordering mode: Regular Logical to Visual Bidi algorithm according to Unicode.
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_DEFAULT = 0;
/** Reordering mode: Logical to Visual algorithm which handles numbers in
* a way which mimicks the behavior of Windows XP.
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_NUMBERS_SPECIAL = 1;
/** Reordering mode: Logical to Visual algorithm grouping numbers with
* adjacent R characters (reversible algorithm).
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_GROUP_NUMBERS_WITH_R = 2;
/** Reordering mode: Reorder runs only to transform a Logical LTR string
* to the logical RTL string with the same display, or vice-versa.
* If this mode is set together with option
* OPTION_INSERT_MARKS, some Bidi controls in the source
* text may be removed and other controls may be added to produce the
* minimum combination which has the required display.
* @see #OPTION_INSERT_MARKS
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_RUNS_ONLY = 3;
/** Reordering mode: Visual to Logical algorithm which handles numbers
* like L (same algorithm as selected by setInverse(true).
* @see #setInverse
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_INVERSE_NUMBERS_AS_L = 4;
/** Reordering mode: Visual to Logical algorithm equivalent to the regular
* Logical to Visual algorithm.
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_INVERSE_LIKE_DIRECT = 5;
/** Reordering mode: Inverse Bidi (Visual to Logical) algorithm for the
* REORDER_NUMBERS_SPECIAL Bidi algorithm.
* @see #setReorderingMode
* @stable ICU 3.8
*/
private static final short REORDER_INVERSE_FOR_NUMBERS_SPECIAL = 6;
/* Reordering mode values must be ordered so that all the regular logical to
* visual modes come first, and all inverse Bidi modes come last.
*/
private static final short REORDER_LAST_LOGICAL_TO_VISUAL =
REORDER_NUMBERS_SPECIAL;
/**
* Option bit for setReorderingOptions:
* insert Bidi marks (LRM or RLM) when needed to ensure correct result of
* a reordering to a Logical order
*
*
This option must be set or reset before calling
* setPara.
This option is significant only with reordering modes which generate * a result with Logical order, specifically.
*REORDER_RUNS_ONLYREORDER_INVERSE_NUMBERS_AS_LREORDER_INVERSE_LIKE_DIRECTREORDER_INVERSE_FOR_NUMBERS_SPECIALIf this option is set in conjunction with reordering mode
* REORDER_INVERSE_NUMBERS_AS_L or with calling
* setInverse(true), it implies option
* INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered().
For other reordering modes, a minimum number of LRM or RLM characters
* will be added to the source text after reordering it so as to ensure
* round trip, i.e. when applying the inverse reordering mode on the
* resulting logical text with removal of Bidi marks
* (option OPTION_REMOVE_CONTROLS set before calling
* setPara() or option
* REMOVE_BIDI_CONTROLS in
* writeReordered), the result will be identical to the
* source text in the first transformation.
*
*
This option will be ignored if specified together with option
* OPTION_REMOVE_CONTROLS. It inhibits option
* REMOVE_BIDI_CONTROLS in calls to method
* writeReordered() and it implies option
* INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered() if the reordering mode is
* REORDER_INVERSE_NUMBERS_AS_L.
setReorderingOptions:
* remove Bidi control characters
*
* This option must be set or reset before calling
* setPara.
This option nullifies option
* OPTION_INSERT_MARKS. It inhibits option
* INSERT_LRM_FOR_NUMERIC in calls to method
* writeReordered() and it implies option
* REMOVE_BIDI_CONTROLS in calls to that method.
setReorderingOptions:
* process the output as part of a stream to be continued
*
* This option must be set or reset before calling
* setPara.
This option specifies that the caller is interested in processing * large text object in parts. The results of the successive calls are * expected to be concatenated by the caller. Only the call for the last * part will have this option bit off.
* *When this option bit is on, setPara() may process
* less than the full source text in order to truncate the text at a
* meaningful boundary. The caller should call
* getProcessedLength() immediately after calling
* setPara() in order to determine how much of the source
* text has been processed. Source text beyond that length should be
* resubmitted in following calls to setPara. The
* processed length may be less than the length of the source text if a
* character preceding the last character of the source text constitutes a
* reasonable boundary (like a block separator) for text to be continued.
* If the last character of the source text constitutes a reasonable
* boundary, the whole text will be processed at once.
* If nowhere in the source text there exists
* such a reasonable boundary, the processed length will be zero.
* The caller should check for such an occurrence and do one of the following:
*
OPTION_STREAMING.When the OPTION_STREAMING option is used, it is
* recommended to call orderParagraphsLTR() with argument
* orderParagraphsLTR set to true before calling
* setPara() so that later paragraphs may be concatenated to
* previous paragraphs on the right.
*
setPara, which may be shorter
* than the original length. Otherwise, it is identical to the original
* length.
*/
public int length;
/* if option OPTION_REMOVE_CONTROLS is set, and/or Bidi
* marks are allowed to be inserted in one of the reordering modes, the
* length of the result string may be different from the processed length.
*/
int resultLength;
/* indicators for whether memory may be allocated after construction */
boolean mayAllocateText;
boolean mayAllocateRuns;
/* arrays with one value per text-character */
byte[] dirPropsMemory = new byte[1];
byte[] levelsMemory = new byte[1];
byte[] dirProps;
byte[] levels;
/* must block separators receive level 0? */
boolean orderParagraphsLTR;
/* the paragraph level */
byte paraLevel;
/* original paraLevel when contextual */
/* must be one of DEFAULT_xxx or 0 if not contextual */
byte defaultParaLevel;
/* the following is set in setPara, used in processPropertySeq */
ImpTabPair impTabPair; /* reference to levels state table pair */
/* the overall paragraph or line directionality*/
byte direction;
/* flags is a bit set for which directional properties are in the text */
int flags;
/* lastArabicPos is index to the last AL in the text, -1 if none */
int lastArabicPos;
/* characters after trailingWSStart are WS and are */
/* implicitly at the paraLevel (rule (L1)) - levels may not reflect that */
int trailingWSStart;
/* fields for paragraph handling */
int paraCount; /* set in getDirProps() */
int[] parasMemory = new int[1];
int[] paras; /* limits of paragraphs, filled in
ResolveExplicitLevels() or CheckExplicitLevels() */
/* for single paragraph text, we only need a tiny array of paras (no allocation) */
int[] simpleParas = {0};
/* fields for line reordering */
int runCount; /* ==-1: runs not set up yet */
BidiRun[] runsMemory = new BidiRun[0];
BidiRun[] runs;
/* for non-mixed text, we only need a tiny array of runs (no allocation) */
BidiRun[] simpleRuns = {new BidiRun()};
/* mapping of runs in logical order to visual order */
int[] logicalToVisualRunsMap;
/* flag to indicate that the map has been updated */
boolean isGoodLogicalToVisualRunsMap;
/* for inverse Bidi with insertion of directional marks */
InsertPoints insertPoints = new InsertPoints();
/* for option OPTION_REMOVE_CONTROLS */
int controlCount;
/*
* Sometimes, bit values are more appropriate
* to deal with directionality properties.
* Abbreviations in these method names refer to names
* used in the Bidi algorithm.
*/
static int DirPropFlag(byte dir) {
return (1 << dir);
}
/*
* The following bit is ORed to the property of characters in paragraphs
* with contextual RTL direction when paraLevel is contextual.
*/
static final byte CONTEXT_RTL_SHIFT = 6;
static final byte CONTEXT_RTL = (byte)(1<Bidi object with preallocated memory
* for internal structures.
* This method provides a Bidi object like the default constructor
* but it also preallocates memory for internal structures
* according to the sizings supplied by the caller.
* The preallocation can be limited to some of the internal memory
* by setting some values to 0 here. That means that if, e.g.,
*
*
* This method takes a piece of plain text containing one or more paragraphs,
* with or without externally specified embedding levels from styled
* text and computes the left-right-directionality of each character.
*
* If the entire text is all of the same directionality, then
* the method may not perform all the steps described by the algorithm,
* i.e., some levels may not be the same as if all steps were performed.
* This is not relevant for unidirectional text.
*
* The text can be composed of multiple paragraphs. Occurrence of a block
* separator in the text terminates a paragraph, and whatever comes next starts
* a new paragraph. The exception to this rule is when a Carriage Return (CR)
* is followed by a Line Feed (LF). Both CR and LF are block separators, but
* in that case, the pair of characters is considered as terminating the
* preceding paragraph, and a new paragraph will be started by a character
* coming after the LF.
*
* Although the text is passed here as a
*
* This method takes a piece of plain text containing one or more paragraphs,
* with or without externally specified embedding levels from styled
* text and computes the left-right-directionality of each character.
*
* If the entire text is all of the same directionality, then
* the method may not perform all the steps described by the algorithm,
* i.e., some levels may not be the same as if all steps were performed.
* This is not relevant for unidirectional text.
*
* The text can be composed of multiple paragraphs. Occurrence of a block
* separator in the text terminates a paragraph, and whatever comes next starts
* a new paragraph. The exception to this rule is when a Carriage Return (CR)
* is followed by a Line Feed (LF). Both CR and LF are block separators, but
* in that case, the pair of characters is considered as terminating the
* preceding paragraph, and a new paragraph will be started by a character
* coming after the LF.
*
* The text is stored internally as an array of characters. Therefore the
* documentation will refer to indexes of the characters in the text.
*
* @param chars contains the text that the Bidi algorithm will be performed
* on. This text can be retrieved with
*
* This method takes a paragraph of text and computes the
* left-right-directionality of each character. The text should not
* contain any Unicode block separators.
*
* The RUN_DIRECTION attribute in the text, if present, determines the base
* direction (left-to-right or right-to-left). If not present, the base
* direction is computed using the Unicode Bidirectional Algorithm,
* defaulting to left-to-right if there are no strong directional characters
* in the text. This attribute, if present, must be applied to all the text
* in the paragraph.
*
* The BIDI_EMBEDDING attribute in the text, if present, represents
* embedding level information. Negative values from -1 to -62 indicate
* overrides at the absolute value of the level. Positive values from 1 to
* 62 indicate embeddings. Where values are zero or not defined, the base
* embedding level as determined by the base direction is assumed.
*
* The NUMERIC_SHAPING attribute in the text, if present, converts European
* digits to other decimal digits before running the bidi algorithm. This
* attribute, if present, must be applied to all the text in the paragraph.
*
* If the entire text is all of the same directionality, then
* the method may not perform all the steps described by the algorithm,
* i.e., some levels may not be the same as if all steps were performed.
* This is not relevant for unidirectional text.
*
* @param paragraph a paragraph of text with optional character and
* paragraph attribute information
* @stable ICU 3.8
*/
public void setPara(AttributedCharacterIterator paragraph)
{
byte paraLvl;
char ch = paragraph.first();
Boolean runDirection =
(Boolean) paragraph.getAttribute(TextAttributeConstants.RUN_DIRECTION);
Object shaper = paragraph.getAttribute(TextAttributeConstants.NUMERIC_SHAPING);
if (runDirection == null) {
paraLvl = INTERNAL_LEVEL_DEFAULT_LTR;
} else {
paraLvl = (runDirection.equals(TextAttributeConstants.RUN_DIRECTION_LTR)) ?
(byte)Bidi.DIRECTION_LEFT_TO_RIGHT : (byte)Bidi.DIRECTION_RIGHT_TO_LEFT;
}
byte[] lvls = null;
int len = paragraph.getEndIndex() - paragraph.getBeginIndex();
byte[] embeddingLevels = new byte[len];
char[] txt = new char[len];
int i = 0;
while (ch != AttributedCharacterIterator.DONE) {
txt[i] = ch;
Integer embedding =
(Integer) paragraph.getAttribute(TextAttributeConstants.BIDI_EMBEDDING);
if (embedding != null) {
byte level = embedding.byteValue();
if (level == 0) {
/* no-op */
} else if (level < 0) {
lvls = embeddingLevels;
embeddingLevels[i] = (byte)((0 - level) | INTERNAL_LEVEL_OVERRIDE);
} else {
lvls = embeddingLevels;
embeddingLevels[i] = level;
}
}
ch = paragraph.next();
++i;
}
if (shaper != null) {
NumericShapings.shape(shaper, txt, 0, len);
}
setPara(txt, paraLvl, lvls);
}
/**
* Specify whether block separators must be allocated level zero,
* so that successive paragraphs will progress from left to right.
* This method must be called before
*
* @param charIndex is the index of a character within the text, in the
* range
* In the new line object, the indexes will range from 0 to
*
* This is used after calling
*
* After line-breaking, rules (L1) and (L2) for the treatment of
* trailing WS and for reordering are performed on
* a
*
* Important: the line
*
* Note that this method may allocate memory under some
* circumstances, unlike
* Some values in the map may be
* When the visual output is altered by using options of
*
* The index map will result in
*
*
* Note: this constructor calls setPara() internally.
*
* @param text an array containing the paragraph of text to process.
* @param textStart the index into the text array of the start of the
* paragraph.
* @param embeddings an array containing embedding values for each character
* in the paragraph. This can be null, in which case it is assumed
* that there is no external embedding information.
* @param embStart the index into the embedding array of the start of the
* paragraph.
* @param paragraphLength the length of the paragraph in the text and
* embeddings arrays.
* @param flags a collection of flags that control the algorithm. The
* algorithm understands the flags DIRECTION_LEFT_TO_RIGHT,
* DIRECTION_RIGHT_TO_LEFT, DIRECTION_DEFAULT_LEFT_TO_RIGHT, and
* DIRECTION_DEFAULT_RIGHT_TO_LEFT. Other values are reserved.
*
* @throws IllegalArgumentException if the values in embeddings are
* not within the allowed range
*
* @see #DIRECTION_LEFT_TO_RIGHT
* @see #DIRECTION_RIGHT_TO_LEFT
* @see #DIRECTION_DEFAULT_LEFT_TO_RIGHT
* @see #DIRECTION_DEFAULT_RIGHT_TO_LEFT
* @stable ICU 3.8
*/
public BidiBase(char[] text,
int textStart,
byte[] embeddings,
int embStart,
int paragraphLength,
int flags)
{
this(0, 0);
byte paraLvl;
switch (flags) {
case Bidi.DIRECTION_LEFT_TO_RIGHT:
default:
paraLvl = Bidi.DIRECTION_LEFT_TO_RIGHT;
break;
case Bidi.DIRECTION_RIGHT_TO_LEFT:
paraLvl = Bidi.DIRECTION_RIGHT_TO_LEFT;
break;
case Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT:
paraLvl = INTERNAL_LEVEL_DEFAULT_LTR;
break;
case Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT:
paraLvl = INTERNAL_LEVEL_DEFAULT_RTL;
break;
}
byte[] paraEmbeddings;
if (embeddings == null) {
paraEmbeddings = null;
} else {
paraEmbeddings = new byte[paragraphLength];
byte lev;
for (int i = 0; i < paragraphLength; i++) {
lev = embeddings[i + embStart];
if (lev < 0) {
lev = (byte)((- lev) | INTERNAL_LEVEL_OVERRIDE);
} else if (lev == 0) {
lev = paraLvl;
if (paraLvl > MAX_EXPLICIT_LEVEL) {
lev &= 1;
}
}
paraEmbeddings[i] = lev;
}
}
if (textStart == 0 && embStart == 0 && paragraphLength == text.length) {
setPara(text, paraLvl, paraEmbeddings);
} else {
char[] paraText = new char[paragraphLength];
System.arraycopy(text, textStart, paraText, 0, paragraphLength);
setPara(paraText, paraLvl, paraEmbeddings);
}
}
/**
* Return true if the line is not left-to-right or right-to-left. This means
* it either has mixed runs of left-to-right and right-to-left text, or the
* base direction differs from the direction of the only run of text.
*
* @return true if the line is not left-to-right or right-to-left.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to maxRunCount cannot be reasonably predetermined and should not
* be set to maxLength (the only failproof value) to avoid
* wasting memory, then maxRunCount could be set to 0 here
* and the internal structures that are associated with it will be allocated
* on demand, just like with the default constructor.
*
* @param maxLength is the maximum text or line length that internal memory
* will be preallocated for. An attempt to associate this object with a
* longer text will fail, unless this value is 0, which leaves the allocation
* up to the implementation.
*
* @param maxRunCount is the maximum anticipated number of same-level runs
* that internal memory will be preallocated for. An attempt to access
* visual runs on an object that was not preallocated for as many runs
* as the text was actually resolved to will fail,
* unless this value is 0, which leaves the allocation up to the implementation.
* The number of runs depends on the actual text and maybe anywhere between
* 1 and maxLength. It is typically small.
*
* @throws IllegalArgumentException if maxLength or maxRunCount is less than 0
* @stable ICU 3.8
*/
public BidiBase(int maxLength, int maxRunCount)
{
/* check the argument values */
if (maxLength < 0 || maxRunCount < 0) {
throw new IllegalArgumentException();
}
/* reset the object, all reference variables null, all flags false,
all sizes 0.
In fact, we don't need to do anything, since class members are
initialized as zero when an instance is created.
*/
/*
mayAllocateText = false;
mayAllocateRuns = false;
orderParagraphsLTR = false;
paraCount = 0;
runCount = 0;
trailingWSStart = 0;
flags = 0;
paraLevel = 0;
defaultParaLevel = 0;
direction = 0;
*/
/* get Bidi properties */
try {
bdp = UBiDiProps.getSingleton();
}
catch (IOException e) {
throw new MissingResourceException(e.getMessage(), "(BidiProps)", "");
}
/* allocate memory for arrays as requested */
if (maxLength > 0) {
getInitialDirPropsMemory(maxLength);
getInitialLevelsMemory(maxLength);
} else {
mayAllocateText = true;
}
if (maxRunCount > 0) {
// if maxRunCount == 1, use simpleRuns[]
if (maxRunCount > 1) {
getInitialRunsMemory(maxRunCount);
}
} else {
mayAllocateRuns = true;
}
}
/*
* We are allowed to allocate memory if object==null or
* mayAllocate==true for each array that we need.
*
* Assume sizeNeeded>0.
* If object != null, then assume size > 0.
*/
private Object getMemory(String label, Object array, Class arrayClass,
boolean mayAllocate, int sizeNeeded)
{
int len = Array.getLength(array);
/* we have at least enough memory and must not allocate */
if (sizeNeeded == len) {
return array;
}
if (!mayAllocate) {
/* we must not allocate */
if (sizeNeeded <= len) {
return array;
}
throw new OutOfMemoryError("Failed to allocate memory for "
+ label);
}
/* we may try to grow or shrink */
/* FOOD FOR THOUGHT: when shrinking it should be possible to avoid
the allocation altogether and rely on this.length */
try {
return Array.newInstance(arrayClass, sizeNeeded);
} catch (Exception e) {
throw new OutOfMemoryError("Failed to allocate memory for "
+ label);
}
}
/* helper methods for each allocated array */
private void getDirPropsMemory(boolean mayAllocate, int len)
{
Object array = getMemory("DirProps", dirPropsMemory, Byte.TYPE, mayAllocate, len);
dirPropsMemory = (byte[]) array;
}
void getDirPropsMemory(int len)
{
getDirPropsMemory(mayAllocateText, len);
}
private void getLevelsMemory(boolean mayAllocate, int len)
{
Object array = getMemory("Levels", levelsMemory, Byte.TYPE, mayAllocate, len);
levelsMemory = (byte[]) array;
}
void getLevelsMemory(int len)
{
getLevelsMemory(mayAllocateText, len);
}
private void getRunsMemory(boolean mayAllocate, int len)
{
Object array = getMemory("Runs", runsMemory, BidiRun.class, mayAllocate, len);
runsMemory = (BidiRun[]) array;
}
void getRunsMemory(int len)
{
getRunsMemory(mayAllocateRuns, len);
}
/* additional methods used by constructor - always allow allocation */
private void getInitialDirPropsMemory(int len)
{
getDirPropsMemory(true, len);
}
private void getInitialLevelsMemory(int len)
{
getLevelsMemory(true, len);
}
private void getInitialParasMemory(int len)
{
Object array = getMemory("Paras", parasMemory, Integer.TYPE, true, len);
parasMemory = (int[]) array;
}
private void getInitialRunsMemory(int len)
{
getRunsMemory(true, len);
}
/* perform (P2)..(P3) ------------------------------------------------------- */
private void getDirProps()
{
int i = 0, i0, i1;
flags = 0; /* collect all directionalities in the text */
int uchar;
byte dirProp;
byte paraDirDefault = 0; /* initialize to avoid compiler warnings */
boolean isDefaultLevel = IsDefaultLevel(paraLevel);
/* for inverse Bidi, the default para level is set to RTL if there is a
strong R or AL character at either end of the text */
lastArabicPos = -1;
controlCount = 0;
final int NOT_CONTEXTUAL = 0; /* 0: not contextual paraLevel */
final int LOOKING_FOR_STRONG = 1; /* 1: looking for first strong char */
final int FOUND_STRONG_CHAR = 2; /* 2: found first strong char */
int state;
int paraStart = 0; /* index of first char in paragraph */
byte paraDir; /* == CONTEXT_RTL within paragraphs
starting with strong R char */
byte lastStrongDir=0; /* for default level & inverse Bidi */
int lastStrongLTR=0; /* for STREAMING option */
if (isDefaultLevel) {
paraDirDefault = ((paraLevel & 1) != 0) ? CONTEXT_RTL : 0;
paraDir = paraDirDefault;
lastStrongDir = paraDirDefault;
state = LOOKING_FOR_STRONG;
} else {
state = NOT_CONTEXTUAL;
paraDir = 0;
}
/* count paragraphs and determine the paragraph level (P2..P3) */
/*
* see comment on constant fields:
* the LEVEL_DEFAULT_XXX values are designed so that
* their low-order bit alone yields the intended default
*/
for (i = 0; i < originalLength; /* i is incremented in the loop */) {
i0 = i; /* index of first code unit */
uchar = UTF16.charAt(text, 0, originalLength, i);
i += Character.charCount(uchar);
i1 = i - 1; /* index of last code unit, gets the directional property */
dirProp = (byte)bdp.getClass(uchar);
flags |= DirPropFlag(dirProp);
dirProps[i1] = (byte)(dirProp | paraDir);
if (i1 > i0) { /* set previous code units' properties to BN */
flags |= DirPropFlag(BN);
do {
dirProps[--i1] = (byte)(BN | paraDir);
} while (i1 > i0);
}
if (state == LOOKING_FOR_STRONG) {
if (dirProp == L) {
state = FOUND_STRONG_CHAR;
if (paraDir != 0) {
paraDir = 0;
for (i1 = paraStart; i1 < i; i1++) {
dirProps[i1] &= ~CONTEXT_RTL;
}
}
continue;
}
if (dirProp == R || dirProp == AL) {
state = FOUND_STRONG_CHAR;
if (paraDir == 0) {
paraDir = CONTEXT_RTL;
for (i1 = paraStart; i1 < i; i1++) {
dirProps[i1] |= CONTEXT_RTL;
}
}
continue;
}
}
if (dirProp == L) {
lastStrongDir = 0;
lastStrongLTR = i; /* i is index to next character */
}
else if (dirProp == R) {
lastStrongDir = CONTEXT_RTL;
}
else if (dirProp == AL) {
lastStrongDir = CONTEXT_RTL;
lastArabicPos = i-1;
}
else if (dirProp == B) {
if (i < originalLength) { /* B not last char in text */
if (!((uchar == (int)CR) && (text[i] == (int)LF))) {
paraCount++;
}
if (isDefaultLevel) {
state=LOOKING_FOR_STRONG;
paraStart = i; /* i is index to next character */
paraDir = paraDirDefault;
lastStrongDir = paraDirDefault;
}
}
}
}
if (isDefaultLevel) {
paraLevel = GetParaLevelAt(0);
}
/* The following line does nothing new for contextual paraLevel, but is
needed for absolute paraLevel. */
flags |= DirPropFlagLR(paraLevel);
if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
flags |= DirPropFlag(L);
}
}
/* perform (X1)..(X9) ------------------------------------------------------- */
/* determine if the text is mixed-directional or single-directional */
private byte directionFromFlags() {
/* if the text contains AN and neutrals, then some neutrals may become RTL */
if (!((flags & MASK_RTL) != 0 ||
((flags & DirPropFlag(AN)) != 0 &&
(flags & MASK_POSSIBLE_N) != 0))) {
return Bidi.DIRECTION_LEFT_TO_RIGHT;
} else if ((flags & MASK_LTR) == 0) {
return Bidi.DIRECTION_RIGHT_TO_LEFT;
} else {
return MIXED;
}
}
/*
* Resolve the explicit levels as specified by explicit embedding codes.
* Recalculate the flags to have them reflect the real properties
* after taking the explicit embeddings into account.
*
* The Bidi algorithm is designed to result in the same behavior whether embedding
* levels are externally specified (from "styled text", supposedly the preferred
* method) or set by explicit embedding codes (LRx, RLx, PDF) in the plain text.
* That is why (X9) instructs to remove all explicit codes (and BN).
* However, in a real implementation, this removal of these codes and their index
* positions in the plain text is undesirable since it would result in
* reallocated, reindexed text.
* Instead, this implementation leaves the codes in there and just ignores them
* in the subsequent processing.
* In order to get the same reordering behavior, positions with a BN or an
* explicit embedding code just get the same level assigned as the last "real"
* character.
*
* Some implementations, not this one, then overwrite some of these
* directionality properties at "real" same-level-run boundaries by
* L or R codes so that the resolution of weak types can be performed on the
* entire paragraph at once instead of having to parse it once more and
* perform that resolution on same-level-runs.
* This limits the scope of the implicit rules in effectively
* the same way as the run limits.
*
* Instead, this implementation does not modify these codes.
* On one hand, the paragraph has to be scanned for same-level-runs, but
* on the other hand, this saves another loop to reset these codes,
* or saves making and modifying a copy of dirProps[].
*
*
* Note that (Pn) and (Xn) changed significantly from version 4 of the Bidi algorithm.
*
*
* Handling the stack of explicit levels (Xn):
*
* With the Bidi stack of explicit levels,
* as pushed with each LRE, RLE, LRO, and RLO and popped with each PDF,
* the explicit level must never exceed MAX_EXPLICIT_LEVEL==61.
*
* In order to have a correct push-pop semantics even in the case of overflows,
* there are two overflow counters:
* - countOver60 is incremented with each LRx at level 60
* - from level 60, one RLx increases the level to 61
* - countOver61 is incremented with each LRx and RLx at level 61
*
* Popping levels with PDF must work in the opposite order so that level 61
* is correct at the correct point. Underflows (too many PDFs) must be checked.
*
* This implementation assumes that MAX_EXPLICIT_LEVEL is odd.
*/
private byte resolveExplicitLevels() {
int i = 0;
byte dirProp;
byte level = GetParaLevelAt(0);
byte dirct;
int paraIndex = 0;
/* determine if the text is mixed-directional or single-directional */
dirct = directionFromFlags();
/* we may not need to resolve any explicit levels, but for multiple
paragraphs we want to loop on all chars to set the para boundaries */
if ((dirct != MIXED) && (paraCount == 1)) {
/* not mixed directionality: levels don't matter - trailingWSStart will be 0 */
} else if ((paraCount == 1) &&
((flags & MASK_EXPLICIT) == 0)) {
/* mixed, but all characters are at the same embedding level */
/* or we are in "inverse Bidi" */
/* and we don't have contextual multiple paragraphs with some B char */
/* set all levels to the paragraph level */
for (i = 0; i < length; ++i) {
levels[i] = level;
}
} else {
/* continue to perform (Xn) */
/* (X1) level is set for all codes, embeddingLevel keeps track of the push/pop operations */
/* both variables may carry the LEVEL_OVERRIDE flag to indicate the override status */
byte embeddingLevel = level;
byte newLevel;
byte stackTop = 0;
byte[] stack = new byte[MAX_EXPLICIT_LEVEL]; /* we never push anything >=MAX_EXPLICIT_LEVEL */
int countOver60 = 0;
int countOver61 = 0; /* count overflows of explicit levels */
/* recalculate the flags */
flags = 0;
for (i = 0; i < length; ++i) {
dirProp = NoContextRTL(dirProps[i]);
switch(dirProp) {
case LRE:
case LRO:
/* (X3, X5) */
newLevel = (byte)((embeddingLevel+2) & ~(INTERNAL_LEVEL_OVERRIDE | 1)); /* least greater even level */
if (newLevel <= MAX_EXPLICIT_LEVEL) {
stack[stackTop] = embeddingLevel;
++stackTop;
embeddingLevel = newLevel;
if (dirProp == LRO) {
embeddingLevel |= INTERNAL_LEVEL_OVERRIDE;
}
/* we don't need to set LEVEL_OVERRIDE off for LRE
since this has already been done for newLevel which is
the source for embeddingLevel.
*/
} else if ((embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) == MAX_EXPLICIT_LEVEL) {
++countOver61;
} else /* (embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) == MAX_EXPLICIT_LEVEL-1 */ {
++countOver60;
}
flags |= DirPropFlag(BN);
break;
case RLE:
case RLO:
/* (X2, X4) */
newLevel=(byte)(((embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) + 1) | 1); /* least greater odd level */
if (newLevel<=MAX_EXPLICIT_LEVEL) {
stack[stackTop] = embeddingLevel;
++stackTop;
embeddingLevel = newLevel;
if (dirProp == RLO) {
embeddingLevel |= INTERNAL_LEVEL_OVERRIDE;
}
/* we don't need to set LEVEL_OVERRIDE off for RLE
since this has already been done for newLevel which is
the source for embeddingLevel.
*/
} else {
++countOver61;
}
flags |= DirPropFlag(BN);
break;
case PDF:
/* (X7) */
/* handle all the overflow cases first */
if (countOver61 > 0) {
--countOver61;
} else if (countOver60 > 0 && (embeddingLevel & ~INTERNAL_LEVEL_OVERRIDE) != MAX_EXPLICIT_LEVEL) {
/* handle LRx overflows from level 60 */
--countOver60;
} else if (stackTop > 0) {
/* this is the pop operation; it also pops level 61 while countOver60>0 */
--stackTop;
embeddingLevel = stack[stackTop];
/* } else { (underflow) */
}
flags |= DirPropFlag(BN);
break;
case B:
stackTop = 0;
countOver60 = 0;
countOver61 = 0;
level = GetParaLevelAt(i);
if ((i + 1) < length) {
embeddingLevel = GetParaLevelAt(i+1);
if (!((text[i] == CR) && (text[i + 1] == LF))) {
paras[paraIndex++] = i+1;
}
}
flags |= DirPropFlag(B);
break;
case BN:
/* BN, LRE, RLE, and PDF are supposed to be removed (X9) */
/* they will get their levels set correctly in adjustWSLevels() */
flags |= DirPropFlag(BN);
break;
default:
/* all other types get the "real" level */
if (level != embeddingLevel) {
level = embeddingLevel;
if ((level & INTERNAL_LEVEL_OVERRIDE) != 0) {
flags |= DirPropFlagO(level) | DirPropFlagMultiRuns;
} else {
flags |= DirPropFlagE(level) | DirPropFlagMultiRuns;
}
}
if ((level & INTERNAL_LEVEL_OVERRIDE) == 0) {
flags |= DirPropFlag(dirProp);
}
break;
}
/*
* We need to set reasonable levels even on BN codes and
* explicit codes because we will later look at same-level runs (X10).
*/
levels[i] = level;
}
if ((flags & MASK_EMBEDDING) != 0) {
flags |= DirPropFlagLR(paraLevel);
}
if (orderParagraphsLTR && (flags & DirPropFlag(B)) != 0) {
flags |= DirPropFlag(L);
}
/* subsequently, ignore the explicit codes and BN (X9) */
/* again, determine if the text is mixed-directional or single-directional */
dirct = directionFromFlags();
}
return dirct;
}
/*
* Use a pre-specified embedding levels array:
*
* Adjust the directional properties for overrides (->LEVEL_OVERRIDE),
* ignore all explicit codes (X9),
* and check all the preset levels.
*
* Recalculate the flags to have them reflect the real properties
* after taking the explicit embeddings into account.
*/
private byte checkExplicitLevels() {
byte dirProp;
int i;
this.flags = 0; /* collect all directionalities in the text */
byte level;
int paraIndex = 0;
for (i = 0; i < length; ++i) {
if (levels[i] == 0) {
levels[i] = paraLevel;
}
if (MAX_EXPLICIT_LEVEL < (levels[i]&0x7f)) {
if ((levels[i] & INTERNAL_LEVEL_OVERRIDE) != 0) {
levels[i] = (byte)(paraLevel|INTERNAL_LEVEL_OVERRIDE);
} else {
levels[i] = paraLevel;
}
}
level = levels[i];
dirProp = NoContextRTL(dirProps[i]);
if ((level & INTERNAL_LEVEL_OVERRIDE) != 0) {
/* keep the override flag in levels[i] but adjust the flags */
level &= ~INTERNAL_LEVEL_OVERRIDE; /* make the range check below simpler */
flags |= DirPropFlagO(level);
} else {
/* set the flags */
flags |= DirPropFlagE(level) | DirPropFlag(dirProp);
}
if ((level < GetParaLevelAt(i) &&
!((0 == level) && (dirProp == B))) ||
(MAX_EXPLICIT_LEVEL
* For example, in pure LTR text with numbers the numbers would get
* a resolved level of 2 higher than the surrounding text according to
* the algorithm. This implementation may set all resolved levels to
* the same value in such a case.String, it is
* stored internally as an array of characters. Therefore the
* documentation will refer to indexes of the characters in the text.
*
* @param text contains the text that the Bidi algorithm will be performed
* on. This text can be retrieved with getText() or
* getTextAsString.
*
* @param paraLevel specifies the default level for the text;
* it is typically 0 (LTR) or 1 (RTL).
* If the method shall determine the paragraph level from the text,
* then paraLevel can be set to
* either LEVEL_DEFAULT_LTR
* or LEVEL_DEFAULT_RTL; if the text contains multiple
* paragraphs, the paragraph level shall be determined separately for
* each paragraph; if a paragraph does not include any strongly typed
* character, then the desired default is used (0 for LTR or 1 for RTL).
* Any other value between 0 and MAX_EXPLICIT_LEVEL
* is also valid, with odd levels indicating RTL.
*
* @param embeddingLevels (in) may be used to preset the embedding and override levels,
* ignoring characters like LRE and PDF in the text.
* A level overrides the directional property of its corresponding
* (same index) character if the level has the
* LEVEL_OVERRIDE bit set.
* Except for that bit, it must be
* paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL,
* with one exception: a level of zero may be specified for a
* paragraph separator even if paraLevel>0 when multiple
* paragraphs are submitted in the same call to setPara().
* Caution: A reference to this array, not a copy
* of the levels, will be stored in the Bidi object;
* the embeddingLevels
* should not be modified to avoid unexpected results on subsequent
* Bidi operations. However, the setPara() and
* setLine() methods may modify some or all of the
* levels.
* Note: the embeddingLevels array must
* have one entry for each character in text.
*
* @throws IllegalArgumentException if the values in embeddingLevels are
* not within the allowed range
*
* @see #LEVEL_DEFAULT_LTR
* @see #LEVEL_DEFAULT_RTL
* @see #LEVEL_OVERRIDE
* @see #MAX_EXPLICIT_LEVEL
* @stable ICU 3.8
*/
void setPara(String text, byte paraLevel, byte[] embeddingLevels)
{
if (text == null) {
setPara(new char[0], paraLevel, embeddingLevels);
} else {
setPara(text.toCharArray(), paraLevel, embeddingLevels);
}
}
/**
* Perform the Unicode Bidi algorithm. It is defined in the
* Unicode Standard Annex #9,
* version 13,
* also described in The Unicode Standard, Version 4.0 .
* For example, in pure LTR text with numbers the numbers would get
* a resolved level of 2 higher than the surrounding text according to
* the algorithm. This implementation may set all resolved levels to
* the same value in such a case.getText() or
* getTextAsString.
*
* @param paraLevel specifies the default level for the text;
* it is typically 0 (LTR) or 1 (RTL).
* If the method shall determine the paragraph level from the text,
* then paraLevel can be set to
* either LEVEL_DEFAULT_LTR
* or LEVEL_DEFAULT_RTL; if the text contains multiple
* paragraphs, the paragraph level shall be determined separately for
* each paragraph; if a paragraph does not include any strongly typed
* character, then the desired default is used (0 for LTR or 1 for RTL).
* Any other value between 0 and MAX_EXPLICIT_LEVEL
* is also valid, with odd levels indicating RTL.
*
* @param embeddingLevels (in) may be used to preset the embedding and
* override levels, ignoring characters like LRE and PDF in the text.
* A level overrides the directional property of its corresponding
* (same index) character if the level has the
* LEVEL_OVERRIDE bit set.
* Except for that bit, it must be
* paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL,
* with one exception: a level of zero may be specified for a
* paragraph separator even if paraLevel>0 when multiple
* paragraphs are submitted in the same call to setPara().
* Caution: A reference to this array, not a copy
* of the levels, will be stored in the Bidi object;
* the embeddingLevels
* should not be modified to avoid unexpected results on subsequent
* Bidi operations. However, the setPara() and
* setLine() methods may modify some or all of the
* levels.
* Note: the embeddingLevels array must
* have one entry for each character in text.
*
* @throws IllegalArgumentException if the values in embeddingLevels are
* not within the allowed range
*
* @see #LEVEL_DEFAULT_LTR
* @see #LEVEL_DEFAULT_RTL
* @see #LEVEL_OVERRIDE
* @see #MAX_EXPLICIT_LEVEL
* @stable ICU 3.8
*/
public void setPara(char[] chars, byte paraLevel, byte[] embeddingLevels)
{
/* check the argument values */
if (paraLevel < INTERNAL_LEVEL_DEFAULT_LTR) {
verifyRange(paraLevel, 0, MAX_EXPLICIT_LEVEL + 1);
}
if (chars == null) {
chars = new char[0];
}
/* initialize the Bidi object */
this.paraBidi = null; /* mark unfinished setPara */
this.text = chars;
this.length = this.originalLength = this.resultLength = text.length;
this.paraLevel = paraLevel;
this.direction = Bidi.DIRECTION_LEFT_TO_RIGHT;
this.paraCount = 1;
/* Allocate zero-length arrays instead of setting to null here; then
* checks for null in various places can be eliminated.
*/
dirProps = new byte[0];
levels = new byte[0];
runs = new BidiRun[0];
isGoodLogicalToVisualRunsMap = false;
insertPoints.size = 0; /* clean up from last call */
insertPoints.confirmed = 0; /* clean up from last call */
/*
* Save the original paraLevel if contextual; otherwise, set to 0.
*/
if (IsDefaultLevel(paraLevel)) {
defaultParaLevel = paraLevel;
} else {
defaultParaLevel = 0;
}
if (length == 0) {
/*
* For an empty paragraph, create a Bidi object with the paraLevel and
* the flags and the direction set but without allocating zero-length arrays.
* There is nothing more to do.
*/
if (IsDefaultLevel(paraLevel)) {
this.paraLevel &= 1;
defaultParaLevel = 0;
}
if ((this.paraLevel & 1) != 0) {
flags = DirPropFlag(R);
direction = Bidi.DIRECTION_RIGHT_TO_LEFT;
} else {
flags = DirPropFlag(L);
direction = Bidi.DIRECTION_LEFT_TO_RIGHT;
}
runCount = 0;
paraCount = 0;
paraBidi = this; /* mark successful setPara */
return;
}
runCount = -1;
/*
* Get the directional properties,
* the flags bit-set, and
* determine the paragraph level if necessary.
*/
getDirPropsMemory(length);
dirProps = dirPropsMemory;
getDirProps();
/* the processed length may have changed if OPTION_STREAMING is set */
trailingWSStart = length; /* the levels[] will reflect the WS run */
/* allocate paras memory */
if (paraCount > 1) {
getInitialParasMemory(paraCount);
paras = parasMemory;
paras[paraCount - 1] = length;
} else {
/* initialize paras for single paragraph */
paras = simpleParas;
simpleParas[0] = length;
}
/* are explicit levels specified? */
if (embeddingLevels == null) {
/* no: determine explicit levels according to the (Xn) rules */
getLevelsMemory(length);
levels = levelsMemory;
direction = resolveExplicitLevels();
} else {
/* set BN for all explicit codes, check that all levels are 0 or paraLevel..MAX_EXPLICIT_LEVEL */
levels = embeddingLevels;
direction = checkExplicitLevels();
}
/*
* The steps after (X9) in the Bidi algorithm are performed only if
* the paragraph text has mixed directionality!
*/
switch (direction) {
case Bidi.DIRECTION_LEFT_TO_RIGHT:
/* make sure paraLevel is even */
paraLevel = (byte)((paraLevel + 1) & ~1);
/* all levels are implicitly at paraLevel (important for getLevels()) */
trailingWSStart = 0;
break;
case Bidi.DIRECTION_RIGHT_TO_LEFT:
/* make sure paraLevel is odd */
paraLevel |= 1;
/* all levels are implicitly at paraLevel (important for getLevels()) */
trailingWSStart = 0;
break;
default:
this.impTabPair = impTab_DEFAULT;
/*
* If there are no external levels specified and there
* are no significant explicit level codes in the text,
* then we can treat the entire paragraph as one run.
* Otherwise, we need to perform the following rules on runs of
* the text with the same embedding levels. (X10)
* "Significant" explicit level codes are ones that actually
* affect non-BN characters.
* Examples for "insignificant" ones are empty embeddings
* LRE-PDF, LRE-RLE-PDF-PDF, etc.
*/
if (embeddingLevels == null && paraCount <= 1 &&
(flags & DirPropFlagMultiRuns) == 0) {
resolveImplicitLevels(0, length,
GetLRFromLevel(GetParaLevelAt(0)),
GetLRFromLevel(GetParaLevelAt(length - 1)));
} else {
/* sor, eor: start and end types of same-level-run */
int start, limit = 0;
byte level, nextLevel;
short sor, eor;
/* determine the first sor and set eor to it because of the loop body (sor=eor there) */
level = GetParaLevelAt(0);
nextLevel = levels[0];
if (level < nextLevel) {
eor = GetLRFromLevel(nextLevel);
} else {
eor = GetLRFromLevel(level);
}
do {
/* determine start and limit of the run (end points just behind the run) */
/* the values for this run's start are the same as for the previous run's end */
start = limit;
level = nextLevel;
if ((start > 0) && (NoContextRTL(dirProps[start - 1]) == B)) {
/* except if this is a new paragraph, then set sor = para level */
sor = GetLRFromLevel(GetParaLevelAt(start));
} else {
sor = eor;
}
/* search for the limit of this run */
while (++limit < length && levels[limit] == level) {}
/* get the correct level of the next run */
if (limit < length) {
nextLevel = levels[limit];
} else {
nextLevel = GetParaLevelAt(length - 1);
}
/* determine eor from max(level, nextLevel); sor is last run's eor */
if ((level & ~INTERNAL_LEVEL_OVERRIDE) < (nextLevel & ~INTERNAL_LEVEL_OVERRIDE)) {
eor = GetLRFromLevel(nextLevel);
} else {
eor = GetLRFromLevel(level);
}
/* if the run consists of overridden directional types, then there
are no implicit types to be resolved */
if ((level & INTERNAL_LEVEL_OVERRIDE) == 0) {
resolveImplicitLevels(start, limit, sor, eor);
} else {
/* remove the LEVEL_OVERRIDE flags */
do {
levels[start++] &= ~INTERNAL_LEVEL_OVERRIDE;
} while (start < limit);
}
} while (limit < length);
}
/* reset the embedding levels for some non-graphic characters (L1), (X9) */
adjustWSLevels();
break;
}
resultLength += insertPoints.size;
paraBidi = this; /* mark successful setPara */
}
/**
* Perform the Unicode Bidi algorithm on a given paragraph, as defined in the
* Unicode Standard Annex #9,
* version 13,
* also described in The Unicode Standard, Version 4.0 .
* For example, in pure LTR text with numbers the numbers would get
* a resolved level of 2 higher than the surrounding text according to
* the algorithm. This implementation may set all resolved levels to
* the same value in such a case.setPara().
* Paragraph separators (B) may appear in the text. Setting them to level zero
* means that all paragraph separators (including one possibly appearing
* in the last text position) are kept in the reordered text after the text
* that they follow in the source text.
* When this feature is not enabled, a paragraph separator at the last
* position of the text before reordering will go to the first position
* of the reordered text when the paragraph level is odd.
*
* @param ordarParaLTR specifies whether paragraph separators (B) must
* receive level 0, so that successive paragraphs progress from left to right.
*
* @see #setPara
* @stable ICU 3.8
*/
private void orderParagraphsLTR(boolean ordarParaLTR) {
orderParagraphsLTR = ordarParaLTR;
}
/**
* Get the directionality of the text.
*
* @return a value of LTR, RTL or MIXED
* that indicates if the entire text
* represented by this object is unidirectional,
* and which direction, or if it is mixed-directional.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
*
* @see #LTR
* @see #RTL
* @see #MIXED
* @stable ICU 3.8
*/
private byte getDirection()
{
verifyValidParaOrLine();
return direction;
}
/**
* Get the length of the text.
*
* @return The length of the text that the Bidi object was
* created for.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @stable ICU 3.8
*/
public int getLength()
{
verifyValidParaOrLine();
return originalLength;
}
/* paragraphs API methods ------------------------------------------------- */
/**
* Get the paragraph level of the text.
*
* @return The paragraph level. If there are multiple paragraphs, their
* level may vary if the required paraLevel is LEVEL_DEFAULT_LTR or
* LEVEL_DEFAULT_RTL. In that case, the level of the first paragraph
* is returned.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
*
* @see #LEVEL_DEFAULT_LTR
* @see #LEVEL_DEFAULT_RTL
* @see #getParagraph
* @see #getParagraphByIndex
* @stable ICU 3.8
*/
public byte getParaLevel()
{
verifyValidParaOrLine();
return paraLevel;
}
/**
* Get the index of a paragraph, given a position within the text.[0..getProcessedLength()-1].
*
* @return The index of the paragraph containing the specified position,
* starting from 0.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @throws IllegalArgumentException if charIndex is not within the legal range
*
* @see com.ibm.icu.text.BidiRun
* @see #getProcessedLength
* @stable ICU 3.8
*/
public int getParagraphIndex(int charIndex)
{
verifyValidParaOrLine();
BidiBase bidi = paraBidi; /* get Para object if Line object */
verifyRange(charIndex, 0, bidi.length);
int paraIndex;
for (paraIndex = 0; charIndex >= bidi.paras[paraIndex]; paraIndex++) {
}
return paraIndex;
}
/**
* setLine() returns a Bidi object to
* contain the reordering information, especially the resolved levels,
* for all the characters in a line of text. This line of text is
* specified by referring to a Bidi object representing
* this information for a piece of text containing one or more paragraphs,
* and by specifying a range of indexes in this text.limit-start-1.setPara()
* for a piece of text, and after line-breaking on that text.
* It is not necessary if each paragraph is treated as a single line.Bidi object that represents a line.Bidi object may
* reference data within the global text Bidi object.
* You should not alter the content of the global text object until
* you are finished using the line object.
*
* @param start is the line's first index into the text.
*
* @param limit is just behind the line's last index into the text
* (its last index +1).
*
* @return a Bidi object that will now represent a line of the text.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara
* @throws IllegalArgumentException if start and limit are not in the range
* 0<=start<limit<=getProcessedLength(),
* or if the specified line crosses a paragraph boundary
*
* @see #setPara
* @see #getProcessedLength
* @stable ICU 3.8
*/
public Bidi setLine(Bidi bidi, BidiBase bidiBase, Bidi newBidi, BidiBase newBidiBase, int start, int limit)
{
verifyValidPara();
verifyRange(start, 0, limit);
verifyRange(limit, 0, length+1);
return BidiLine.setLine(bidi, this, newBidi, newBidiBase, start, limit);
}
/**
* Get the level for one character.
*
* @param charIndex the index of a character.
*
* @return The level for the character at charIndex.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @throws IllegalArgumentException if charIndex is not in the range
* 0<=charIndex<getProcessedLength()
*
* @see #getProcessedLength
* @stable ICU 3.8
*/
public byte getLevelAt(int charIndex)
{
if (charIndex < 0 || charIndex >= length) {
return (byte)getBaseLevel();
}
verifyValidParaOrLine();
verifyRange(charIndex, 0, length);
return BidiLine.getLevelAt(this, charIndex);
}
/**
* Get an array of levels for each character.getLevelAt().
*
* @return The levels array for the text,
* or null if an error occurs.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @stable ICU 3.8
*/
private byte[] getLevels()
{
verifyValidParaOrLine();
if (length <= 0) {
return new byte[0];
}
return BidiLine.getLevels(this);
}
/**
* Get the number of runs.
* This method may invoke the actual reordering on the
* Bidi object, after setPara()
* may have resolved only the levels of the text. Therefore,
* countRuns() may have to allocate memory,
* and may throw an exception if it fails to do so.
*
* @return The number of runs.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @stable ICU 3.8
*/
public int countRuns()
{
verifyValidParaOrLine();
BidiLine.getRuns(this);
return runCount;
}
/**
* Get a visual-to-logical index map (array) for the characters in the
* Bidi (paragraph or line) object.
* MAP_NOWHERE if the
* corresponding text characters are Bidi marks inserted in the visual
* output by the option OPTION_INSERT_MARKS.
* writeReordered() such as INSERT_LRM_FOR_NUMERIC,
* KEEP_BASE_COMBINING, OUTPUT_REVERSE,
* REMOVE_BIDI_CONTROLS, the logical positions returned may not
* be correct. It is advised to use, when possible, reordering options
* such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
*
* @return an array of getResultLength()
* indexes which will reflect the reordering of the characters.
* The index map will result in
* indexMap[visualIndex]==logicalIndex, where
* indexMap represents the returned array.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
*
* @see #getLogicalMap
* @see #getLogicalIndex
* @see #getResultLength
* @see #MAP_NOWHERE
* @see #OPTION_INSERT_MARKS
* @see #writeReordered
* @stable ICU 3.8
*/
private int[] getVisualMap()
{
/* countRuns() checks successful call to setPara/setLine */
countRuns();
if (resultLength <= 0) {
return new int[0];
}
return BidiLine.getVisualMap(this);
}
/**
* This is a convenience method that does not use a Bidi object.
* It is intended to be used for when an application has determined the levels
* of objects (character sequences) and just needs to have them reordered (L2).
* This is equivalent to using getVisualMap() on a
* Bidi object.
*
* @param levels is an array of levels that have been determined by
* the application.
*
* @return an array of levels.length
* indexes which will reflect the reordering of the characters.indexMap[visualIndex]==logicalIndex, where
* indexMap represents the returned array.
*
* @stable ICU 3.8
*/
private static int[] reorderVisual(byte[] levels)
{
return BidiLine.reorderVisual(levels);
}
/**
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present, the base
* direction is left-to-right.
* @stable ICU 3.8
*/
private static final int INTERNAL_DIRECTION_DEFAULT_LEFT_TO_RIGHT = 0x7e;
/**
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present, the base
* direction is right-to-left.
* @stable ICU 3.8
*/
private static final int INTERMAL_DIRECTION_DEFAULT_RIGHT_TO_LEFT = 0x7f;
/**
* Create Bidi from the given text, embedding, and direction information.
* The embeddings array may be null. If present, the values represent
* embedding level information. Negative values from -1 to -61 indicate
* overrides at the absolute value of the level. Positive values from 1 to
* 61 indicate embeddings. Where values are zero, the base embedding level
* as determined by the base direction is assumed.setPara
* @stable ICU 3.8
*/
public boolean isMixed()
{
return (!isLeftToRight() && !isRightToLeft());
}
/**
* Return true if the line is all left-to-right text and the base direction
* is left-to-right.
*
* @return true if the line is all left-to-right text and the base direction
* is left-to-right.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara
* @stable ICU 3.8
*/
public boolean isLeftToRight()
{
return (getDirection() == Bidi.DIRECTION_LEFT_TO_RIGHT && (paraLevel & 1) == 0);
}
/**
* Return true if the line is all right-to-left text, and the base direction
* is right-to-left
*
* @return true if the line is all right-to-left text, and the base
* direction is right-to-left
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara
* @stable ICU 3.8
*/
public boolean isRightToLeft()
{
return (getDirection() == Bidi.DIRECTION_RIGHT_TO_LEFT && (paraLevel & 1) == 1);
}
/**
* Return true if the base direction is left-to-right
*
* @return true if the base direction is left-to-right
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
*
* @stable ICU 3.8
*/
public boolean baseIsLeftToRight()
{
return (getParaLevel() == Bidi.DIRECTION_LEFT_TO_RIGHT);
}
/**
* Return the base level (0 if left-to-right, 1 if right-to-left).
*
* @return the base level
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
*
* @stable ICU 3.8
*/
public int getBaseLevel()
{
return getParaLevel();
}
/**
* Compute the logical to visual run mapping
*/
private void getLogicalToVisualRunsMap()
{
if (isGoodLogicalToVisualRunsMap) {
return;
}
int count = countRuns();
if ((logicalToVisualRunsMap == null) ||
(logicalToVisualRunsMap.length < count)) {
logicalToVisualRunsMap = new int[count];
}
int i;
long[] keys = new long[count];
for (i = 0; i < count; i++) {
keys[i] = ((long)(runs[i].start)<<32) + i;
}
Arrays.sort(keys);
for (i = 0; i < count; i++) {
logicalToVisualRunsMap[i] = (int)(keys[i] & 0x00000000FFFFFFFF);
}
keys = null;
isGoodLogicalToVisualRunsMap = true;
}
/**
* Return the level of the nth logical run in this line.
*
* @param run the index of the run, between 0 and countRuns()-1
*
* @return the level of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @throws IllegalArgumentException if run is not in
* the range 0<=run<countRuns()
* @stable ICU 3.8
*/
public int getRunLevel(int run)
{
verifyValidParaOrLine();
BidiLine.getRuns(this);
if (run < 0 || run >= runCount) {
return getParaLevel();
}
getLogicalToVisualRunsMap();
return runs[logicalToVisualRunsMap[run]].level;
}
/**
* Return the index of the character at the start of the nth logical run in
* this line, as an offset from the start of the line.
*
* @param run the index of the run, between 0 and countRuns()
*
* @return the start of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @throws IllegalArgumentException if run is not in
* the range 0<=run<countRuns()
* @stable ICU 3.8
*/
public int getRunStart(int run)
{
verifyValidParaOrLine();
BidiLine.getRuns(this);
if (runCount == 1) {
return 0;
} else if (run == runCount) {
return length;
}
verifyIndex(run, 0, runCount);
getLogicalToVisualRunsMap();
return runs[logicalToVisualRunsMap[run]].start;
}
/**
* Return the index of the character past the end of the nth logical run in
* this line, as an offset from the start of the line. For example, this
* will return the length of the line for the last run on the line.
*
* @param run the index of the run, between 0 and countRuns()
*
* @return the limit of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to setPara or setLine
* @throws IllegalArgumentException if run is not in
* the range 0<=run<countRuns()
* @stable ICU 3.8
*/
public int getRunLimit(int run)
{
verifyValidParaOrLine();
BidiLine.getRuns(this);
if (runCount == 1) {
return length;
}
verifyIndex(run, 0, runCount);
getLogicalToVisualRunsMap();
int idx = logicalToVisualRunsMap[run];
int len = idx == 0 ? runs[idx].limit :
runs[idx].limit - runs[idx-1].limit;
return runs[idx].start + len;
}
/**
* Return true if the specified text requires bidi analysis. If this returns
* false, the text will display left-to-right. Clients can then avoid
* constructing a Bidi object. Text in the Arabic Presentation Forms area of
* Unicode is presumed to already be shaped and ordered for display, and so
* will not cause this method to return true.
*
* @param text the text containing the characters to test
* @param start the start of the range of characters to test
* @param limit the limit of the range of characters to test
*
* @return true if the range of characters requires bidi analysis
*
* @stable ICU 3.8
*/
public static boolean requiresBidi(char[] text,
int start,
int limit)
{
final int RTLMask = (1 << Bidi.DIRECTION_RIGHT_TO_LEFT |
1 << AL |
1 << RLE |
1 << RLO |
1 << AN);
if (0 > start || start > limit || limit > text.length) {
throw new IllegalArgumentException("Value start " + start +
" is out of range 0 to " + limit);
}
for (int i = start; i < limit; ++i) {
if (Character.isHighSurrogate(text[i]) && i < (limit-1) &&
Character.isLowSurrogate(text[i+1])) {
if (((1 << UCharacter.getDirection(Character.codePointAt(text, i))) & RTLMask) != 0) {
return true;
}
} else if (((1 << UCharacter.getDirection(text[i])) & RTLMask) != 0) {
return true;
}
}
return false;
}
/**
* Reorder the objects in the array into visual order based on their levels.
* This is a utility method to use when you have a collection of objects
* representing runs of text in logical order, each run containing text at a
* single level. The elements at index from
* objectStart up to objectStart + count in the
* objects array will be reordered into visual order assuming
* each run of text has the level indicated by the corresponding element in
* the levels array (at index - objectStart + levelStart).
*
* @param levels an array representing the bidi level of each object
* @param levelStart the start position in the levels array
* @param objects the array of objects to be reordered into visual order
* @param objectStart the start position in the objects array
* @param count the number of objects to reorder
* @stable ICU 3.8
*/
public static void reorderVisually(byte[] levels,
int levelStart,
Object[] objects,
int objectStart,
int count)
{
if (0 > levelStart || levels.length <= levelStart) {
throw new IllegalArgumentException("Value levelStart " +
levelStart + " is out of range 0 to " +
(levels.length-1));
}
if (0 > objectStart || objects.length <= objectStart) {
throw new IllegalArgumentException("Value objectStart " +
levelStart + " is out of range 0 to " +
(objects.length-1));
}
if (0 > count || objects.length < (objectStart+count)) {
throw new IllegalArgumentException("Value count " +
levelStart + " is out of range 0 to " +
(objects.length - objectStart));
}
byte[] reorderLevels = new byte[count];
System.arraycopy(levels, levelStart, reorderLevels, 0, count);
int[] indexMap = reorderVisual(reorderLevels);
Object[] temp = new Object[count];
System.arraycopy(objects, objectStart, temp, 0, count);
for (int i = 0; i < count; ++i) {
objects[objectStart + i] = temp[indexMap[i]];
}
}
/**
* Display the bidi internal state, used in debugging.
*/
public String toString() {
StringBuilder buf = new StringBuilder(getClass().getName());
buf.append("[dir: ");
buf.append(direction);
buf.append(" baselevel: ");
buf.append(paraLevel);
buf.append(" length: ");
buf.append(length);
buf.append(" runs: ");
if (levels == null) {
buf.append("none");
} else {
buf.append('[');
buf.append(levels[0]);
for (int i = 1; i < levels.length; i++) {
buf.append(' ');
buf.append(levels[i]);
}
buf.append(']');
}
buf.append(" text: [0x");
buf.append(Integer.toHexString(text[0]));
for (int i = 1; i < text.length; i++) {
buf.append(" 0x");
buf.append(Integer.toHexString(text[i]));
}
buf.append("]]");
return buf.toString();
}
/**
* A class that provides access to constants defined by
* java.awt.font.TextAttribute without creating a static dependency.
*/
private static class TextAttributeConstants {
private static final Class clazz = getClass("java.awt.font.TextAttribute");
/**
* TextAttribute instances (or a fake Attribute type if
* java.awt.font.TextAttribute is not present)
*/
static final AttributedCharacterIterator.Attribute RUN_DIRECTION =
getTextAttribute("RUN_DIRECTION");
static final AttributedCharacterIterator.Attribute NUMERIC_SHAPING =
getTextAttribute("NUMERIC_SHAPING");
static final AttributedCharacterIterator.Attribute BIDI_EMBEDDING =
getTextAttribute("BIDI_EMBEDDING");
/**
* TextAttribute.RUN_DIRECTION_LTR
*/
static final Boolean RUN_DIRECTION_LTR = (clazz == null) ?
Boolean.FALSE : (Boolean)getStaticField(clazz, "RUN_DIRECTION_LTR");
private static Class getClass(String name) {
try {
return Class.forName(name, true, null);
} catch (ClassNotFoundException e) {
return null;
}
}
private static Object getStaticField(Class clazz, String name) {
try {
Field f = clazz.getField(name);
return f.get(null);
} catch (NoSuchFieldException | IllegalAccessException x) {
throw new AssertionError(x);
}
}
private static AttributedCharacterIterator.Attribute
getTextAttribute(String name)
{
if (clazz == null) {
// fake attribute
return new AttributedCharacterIterator.Attribute(name) { };
} else {
return (AttributedCharacterIterator.Attribute)getStaticField(clazz, name);
}
}
}
/**
* A class that provides access to java.awt.font.NumericShaping without
* creating a static dependency.
*/
private static class NumericShapings {
private static final Class clazz =
getClass("java.awt.font.NumericShaper");
private static final Method shapeMethod =
getMethod(clazz, "shape", char[].class, int.class, int.class);
private static Class getClass(String name) {
try {
return Class.forName(name, true, null);
} catch (ClassNotFoundException e) {
return null;
}
}
private static Method getMethod(Class clazz,
String name,
Class... paramTypes)
{
if (clazz != null) {
try {
return clazz.getMethod(name, paramTypes);
} catch (NoSuchMethodException e) {
throw new AssertionError(e);
}
} else {
return null;
}
}
/**
* Invokes NumericShaping shape(text,start,count) method.
*/
static void shape(Object shaper, char[] text, int start, int count) {
if (shapeMethod == null)
throw new AssertionError("Should not get here");
try {
shapeMethod.invoke(shaper, text, start, count);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof RuntimeException)
throw (RuntimeException)cause;
throw new AssertionError(e);
} catch (IllegalAccessException iae) {
throw new AssertionError(iae);
}
}
}
}