com.lowagie.text.pdf
public final class BidiOrder extends Object
This implementation is not optimized for performance. It is intended as a reference implementation that closely follows the specification of the Bidirectional Algorithm in The Unicode Standard version 3.0.
Input:
There are two levels of input to the algorithm, since clients may prefer
to supply some information from out-of-band sources rather than relying on
the default behavior.
Output:
Output is separated into several stages as well, to better enable clients
to evaluate various aspects of implementation conformance.
As the algorithm is defined to operate on a single paragraph at a time, this implementation is written to handle single paragraphs. Thus rule P1 is presumed by this implementation-- the data provided to the implementation is assumed to be a single paragraph, and either contains no 'B' codes, or a single 'B' code at the end of the input. 'B' is allowed as input to illustrate how the algorithm assigns it a level.
Also note that rules L3 and L4 depend on the rendering engine that uses the result of the bidi algorithm. This implementation assumes that the rendering engine expects combining marks in visual order (e.g. to the left of their base character in RTL runs) and that it adjust the glyphs used to render mirrored characters that are in RTL runs so that they render appropriately.
Field Summary | |
---|---|
static byte | AL Right-to-Left Arabic |
static byte | AN Arabic Number |
static char[] | baseTypes |
static byte | B Paragraph Separator |
static byte | BN Boundary Neutral |
static byte | CS Common Number Separator |
byte[] | embeddings |
static byte | EN European Number |
static byte | ES European Number Separator |
static byte | ET European Number Terminator |
byte[] | initialTypes |
static byte | L Left-to-right |
static byte | LRE Left-to-Right Embedding |
static byte | LRO Left-to-Right Override |
static byte | NSM Non-Spacing Mark |
static byte | ON Other Neutrals |
byte | paragraphEmbeddingLevel |
static byte | PDF Pop Directional Format |
byte[] | resultLevels |
byte[] | resultTypes |
static byte[] | rtypes |
static byte | R Right-to-Left |
static byte | RLE Right-to-Left Embedding |
static byte | RLO Right-to-Left Override |
static byte | S Segment Separator |
int | textLength |
static byte | TYPE_MAX Maximum bidi type value. |
static byte | TYPE_MIN Minimum bidi type value. |
static byte | WS Whitespace |
Constructor Summary | |
---|---|
BidiOrder(byte[] types)
Initialize using an array of direction types. | |
BidiOrder(byte[] types, byte paragraphEmbeddingLevel)
Initialize using an array of direction types and an externally supplied paragraph embedding level.
| |
BidiOrder(char[] text, int offset, int length, byte paragraphEmbeddingLevel) |
Method Summary | |
---|---|
static int[] | computeMultilineReordering(byte[] levels, int[] linebreaks)
Return multiline reordering array for a given level array.
|
static int[] | computeReordering(byte[] levels)
Return reordering array for a given level array. |
void | determineExplicitEmbeddingLevels()
Process embedding format codes.
|
void | determineParagraphEmbeddingLevel()
1) determining the paragraph level.
|
int | findRunLimit(int index, int limit, byte[] validSet)
Return the limit of the run starting at index that includes only resultTypes in validSet.
|
int | findRunStart(int index, byte[] validSet)
Return the start of the run including index that includes only resultTypes in validSet.
|
byte | getBaseLevel()
Return the base level of the paragraph. |
static byte | getDirection(char c) |
byte[] | getLevels() |
byte[] | getLevels(int[] linebreaks)
Return levels array breaking lines at offsets in linebreaks. |
int[] | getReordering(int[] linebreaks)
Return reordering array breaking lines at offsets in linebreaks.
|
static boolean | isWhitespace(byte biditype)
Return true if the type is considered a whitespace type for the line break rules. |
static byte[] | processEmbeddings(byte[] resultTypes, byte paragraphEmbeddingLevel)
2) determining explicit levels
Rules X1 - X8
The interaction of these rules makes handling them a bit complex.
|
int | reinsertExplicitCodes(int textLength)
Reinsert levels information for explicit codes.
|
int | removeExplicitCodes()
Rules X9.
|
void | resolveImplicitLevels(int start, int limit, byte level, byte sor, byte eor)
7) resolving implicit embedding levels
Rules I1, I2. |
void | resolveNeutralTypes(int start, int limit, byte level, byte sor, byte eor)
6) resolving neutral types
Rules N1-N2. |
void | resolveWeakTypes(int start, int limit, byte level, byte sor, byte eor)
3) resolving weak types
Rules W1-W7.
|
void | runAlgorithm()
The algorithm.
|
void | setLevels(int start, int limit, byte newLevel)
Set resultLevels from start up to (but not including) limit to newLevel. |
void | setTypes(int start, int limit, byte newType)
Set resultTypes from start up to (but not including) limit to newType. |
static byte | typeForLevel(int level)
Return the strong type (L or R) corresponding to the level. |
static void | validateLineBreaks(int[] linebreaks, int textLength)
Throw exception if line breaks array is invalid. |
static void | validateParagraphEmbeddingLevel(byte paragraphEmbeddingLevel)
Throw exception if paragraph embedding level is invalid. |
static void | validateTypes(byte[] types)
Throw exception if type array is invalid. |
Parameters: types the types array
Parameters: types the types array paragraphEmbeddingLevel the externally supplied paragraph embedding level.
Calls processEmbeddings to generate an embedding array from the explicit format codes. The embedding overrides in the array are then applied to the result types, and the result levels are initialized.
See Also: BidiOrder
Rules P2, P3.
At the end of this function, the member variable paragraphEmbeddingLevel is set to either 0 or 1.
The returned levels array contains the resolved level for each bidi code passed to the constructor.
The linebreaks array must include at least one value. The values must be in strictly increasing order (no duplicates) between 1 and the length of the text, inclusive. The last value must be the length of the text.
Parameters: linebreaks the offsets at which to break the paragraph
Returns: the resolved levels of the text
The reordering array maps from a visual index to a logical index. Lines are concatenated from left to right. So for example, the fifth character from the left on the third line is
getReordering(linebreaks)[linebreaks[1] + 4](linebreaks[1] is the position after the last character of the second line, which is also the index of the first character on the third line, and adding four gets the fifth character from the left).
The linebreaks array must include at least one value. The values must be in strictly increasing order (no duplicates) between 1 and the length of the text, inclusive. The last value must be the length of the text.
Parameters: linebreaks the offsets at which to break the paragraph.
Parameters: textLength the length of the data after compression
Returns: the length of the data (original length of types array supplied to constructor)
Returns: the length of the data excluding explicit codes and BN.