| java.lang.Object
 com.lowagie.text.pdf.BidiOrder
| BidiOrder | | final public class BidiOrder (Code) | | Reference implementation of the Unicode 3.0 Bidi algorithm.
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.
- unicode type array
- unicode type array, with externally supplied base line direction
Output:
Output is separated into several stages as well, to better enable clients
to evaluate various aspects of implementation conformance.
- levels array over entire paragraph
- reordering array over entire paragraph
- levels array over line
- reordering array over line
Note that for conformance, algorithms are only required to generate correct
reordering and character directionality (odd or even levels) over a line.
Generating identical level arrays over a line is not required. Bidi
explicit format codes (LRE, RLE, LRO, RLO, PDF) and BN can be assigned
arbitrary levels and positions as long as the other text matches.
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.
author:
Doug Felt |
| Field Summary | |
| final public static byte | AL
| | final public static byte | AN
| | final public static byte | B
| | final public static byte | BN
| | final public static byte | CS
| | final public static byte | EN
| | final public static byte | ES
| | final public static byte | ET
| | final public static byte | L
| | final public static byte | LRE
| | final public static byte | LRO
| | final public static byte | NSM
| | final public static byte | ON
| | final public static byte | PDF
| | final public static byte | R
| | final public static byte | RLE
| | final public static byte | RLO
| | final public static byte | S
| | final public static byte | TYPE_MAX
Maximum bidi type value. | | final public static byte | TYPE_MIN
Minimum bidi type value. | | final public static byte | WS
|
| Constructor Summary | |
| public | BidiOrder(byte[] types)
Initialize using an array of direction types. | | public | BidiOrder(byte[] types, byte paragraphEmbeddingLevel)
Initialize using an array of direction types and an externally supplied paragraph embedding level.
The embedding level may be -1, 0, or 1. | | public | BidiOrder(char text, int offset, int length, byte paragraphEmbeddingLevel)
|
| Method Summary | |
| public byte | getBaseLevel()
Return the base level of the paragraph. | | final public static byte | getDirection(char c)
| | public byte[] | getLevels()
| | public byte[] | getLevels(int[] linebreaks)
Return levels array breaking lines at offsets in linebreaks. | | public int[] | getReordering(int[] linebreaks)
Return reordering array breaking lines at offsets in linebreaks.
The reordering array maps from a visual index to a logical index.
Lines are concatenated from left to right. |
| AL | | final public static byte AL(Code) | | Right-to-Left Arabic
|
| AN | | final public static byte AN(Code) | | Arabic Number
|
| B | | final public static byte B(Code) | | Paragraph Separator
|
| BN | | final public static byte BN(Code) | | Boundary Neutral
|
| CS | | final public static byte CS(Code) | | Common Number Separator
|
| EN | | final public static byte EN(Code) | | European Number
|
| ES | | final public static byte ES(Code) | | European Number Separator
|
| ET | | final public static byte ET(Code) | | European Number Terminator
|
| L | | final public static byte L(Code) | | Left-to-right
|
| LRE | | final public static byte LRE(Code) | | Left-to-Right Embedding
|
| LRO | | final public static byte LRO(Code) | | Left-to-Right Override
|
| NSM | | final public static byte NSM(Code) | | Non-Spacing Mark
|
| ON | | final public static byte ON(Code) | | Other Neutrals
|
| PDF | | final public static byte PDF(Code) | | Pop Directional Format
|
| R | | final public static byte R(Code) | | Right-to-Left
|
| RLE | | final public static byte RLE(Code) | | Right-to-Left Embedding
|
| RLO | | final public static byte RLO(Code) | | Right-to-Left Override
|
| S | | final public static byte S(Code) | | Segment Separator
|
| TYPE_MAX | | final public static byte TYPE_MAX(Code) | | Maximum bidi type value.
|
| TYPE_MIN | | final public static byte TYPE_MIN(Code) | | Minimum bidi type value.
|
| WS | | final public static byte WS(Code) | | Whitespace
|
| BidiOrder | | public BidiOrder(byte[] types)(Code) | | Initialize using an array of direction types. Types range from TYPE_MIN to TYPE_MAX inclusive
and represent the direction codes of the characters in the text.
Parameters:
types - the types array |
| BidiOrder | | public BidiOrder(byte[] types, byte paragraphEmbeddingLevel)(Code) | | Initialize using an array of direction types and an externally supplied paragraph embedding level.
The embedding level may be -1, 0, or 1. -1 means to apply the default algorithm (rules P2 and P3),
0 is for LTR paragraphs, and 1 is for RTL paragraphs.
Parameters:
types - the types array
Parameters:
paragraphEmbeddingLevel - the externally supplied paragraph embedding level. |
| BidiOrder | | public BidiOrder(char text, int offset, int length, byte paragraphEmbeddingLevel)(Code) | | |
| getBaseLevel | | public byte getBaseLevel()(Code) | | Return the base level of the paragraph.
|
| getDirection | | final public static byte getDirection(char c)(Code) | | |
| getLevels | | public byte[] getLevels()(Code) | | |
| getLevels | | public byte[] getLevels(int[] linebreaks)(Code) | | Return levels array breaking lines at offsets in linebreaks.
Rule L1.
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 the resolved levels of the text |
| getReordering | | public int[] getReordering(int[] linebreaks)(Code) | | Return reordering array breaking lines at offsets in linebreaks.
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. |
|
|