Java Code Examples for java.text.Bidi#getRunLevel()

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the array
 * @throws IndexOutOfBoundsException if {@code start} is less than 0 or
 * {@code start + getLength()} is greater than {@code levels.length}.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

/**
 * Return the level of each character into the levels array starting at start.
 * This is a convenience method for clients who prefer to use an explicit levels
 * array instead of iterating over the runs.
 *
 * @param levels the array to receive the character levels
 * @param start the starting offset into the the array
 * @throws IndexOutOfBoundsException if <code>start</code> is less than 0 or
 * <code>start + getLength()</code> is greater than <code>levels.length</code>.
 */
public static void getLevels(Bidi bidi, byte[] levels, int start) {
    int limit = start + bidi.getLength();

    if (start < 0 || limit > levels.length) {
        throw new IndexOutOfBoundsException("levels.length = " + levels.length +
            " start: " + start + " limit: " + limit);
    }

    int runCount = bidi.getRunCount();
    int p = start;
    for (int i = 0; i < runCount; ++i) {
        int rlimit = start + bidi.getRunLimit(i);
        byte rlevel = (byte)bidi.getRunLevel(i);

        while (p < rlimit) {
            levels[p++] = rlevel;
        }
    }
}
 

void testBidi(String string, int rtlstart, int rtllength) {
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    for (int i = 0; i < bidi.getRunCount(); ++i) {
        if ((bidi.getRunLevel(i) & 1) != 0) {
            if (bidi.getRunStart(i) != rtlstart ||
                bidi.getRunLimit(i) != rtlstart + rtllength) {
                throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
            }
            break;
        }
    }
}
 

void testBidi(String string, int rtlstart, int rtllength) {
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    for (int i = 0; i < bidi.getRunCount(); ++i) {
        if ((bidi.getRunLevel(i) & 1) != 0) {
            if (bidi.getRunStart(i) != rtlstart ||
                bidi.getRunLimit(i) != rtlstart + rtllength) {
                throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
            }
            break;
        }
    }
}
 

void testBidi(String string, int rtlstart, int rtllength) {
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    for (int i = 0; i < bidi.getRunCount(); ++i) {
        if ((bidi.getRunLevel(i) & 1) != 0) {
            if (bidi.getRunStart(i) != rtlstart ||
                bidi.getRunLimit(i) != rtlstart + rtllength) {
                throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
            }
            break;
        }
    }
}
 

public static void main(String[] args) {
    boolean err = false;
    String string = "\u05D0\u05D1\u05D2";
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_LEFT_TO_RIGHT);

    int result = bidi.getRunCount();
    if (result != 1) {
        System.err.println("Incorrect run count: " + result);
        err = true;
    }

    result = bidi.getRunStart(0);
    if (result != 0) {
        System.err.println("Incorrect run start: " + result);
        err = true;
    }

    result = bidi.getRunLimit(0);
    if (result != 3) {
        System.err.println("Incorrect run limit: " + result);
        err = true;
    }

    result = bidi.getRunLevel(0);
    if (result != 1) {
        System.err.println("Incorrect run level: " + result);
        err = true;
    }

    if (err) {
        throw new RuntimeException("Failed.");
    }
}
 

public static void main(String[] args) {
    boolean err = false;
    String string = "\u05D0\u05D1\u05D2";
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_LEFT_TO_RIGHT);

    int result = bidi.getRunCount();
    if (result != 1) {
        System.err.println("Incorrect run count: " + result);
        err = true;
    }

    result = bidi.getRunStart(0);
    if (result != 0) {
        System.err.println("Incorrect run start: " + result);
        err = true;
    }

    result = bidi.getRunLimit(0);
    if (result != 3) {
        System.err.println("Incorrect run limit: " + result);
        err = true;
    }

    result = bidi.getRunLevel(0);
    if (result != 1) {
        System.err.println("Incorrect run level: " + result);
        err = true;
    }

    if (err) {
        throw new RuntimeException("Failed.");
    }
}
 

void testBidi(String string, int rtlstart, int rtllength) {
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    for (int i = 0; i < bidi.getRunCount(); ++i) {
        if ((bidi.getRunLevel(i) & 1) != 0) {
            if (bidi.getRunStart(i) != rtlstart ||
                bidi.getRunLimit(i) != rtlstart + rtllength) {
                throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
            }
            break;
        }
    }
}
 

public static void main(String[] args) {
    boolean err = false;
    String string = "\u05D0\u05D1\u05D2";
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_LEFT_TO_RIGHT);

    int result = bidi.getRunCount();
    if (result != 1) {
        System.err.println("Incorrect run count: " + result);
        err = true;
    }

    result = bidi.getRunStart(0);
    if (result != 0) {
        System.err.println("Incorrect run start: " + result);
        err = true;
    }

    result = bidi.getRunLimit(0);
    if (result != 3) {
        System.err.println("Incorrect run limit: " + result);
        err = true;
    }

    result = bidi.getRunLevel(0);
    if (result != 1) {
        System.err.println("Incorrect run level: " + result);
        err = true;
    }

    if (err) {
        throw new RuntimeException("Failed.");
    }
}
 

void testBidi(String string, int rtlstart, int rtllength) {
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
    for (int i = 0; i < bidi.getRunCount(); ++i) {
        if ((bidi.getRunLevel(i) & 1) != 0) {
            if (bidi.getRunStart(i) != rtlstart ||
                bidi.getRunLimit(i) != rtlstart + rtllength) {
                throw new RuntimeException("first rtl run didn't match " + rtlstart + ", " + rtllength);
            }
            break;
        }
    }
}
 

public static void main(String[] args) {
    boolean err = false;
    String string = "\u05D0\u05D1\u05D2";
    Bidi bidi = new Bidi(string, Bidi.DIRECTION_LEFT_TO_RIGHT);

    int result = bidi.getRunCount();
    if (result != 1) {
        System.err.println("Incorrect run count: " + result);
        err = true;
    }

    result = bidi.getRunStart(0);
    if (result != 0) {
        System.err.println("Incorrect run start: " + result);
        err = true;
    }

    result = bidi.getRunLimit(0);
    if (result != 3) {
        System.err.println("Incorrect run limit: " + result);
        err = true;
    }

    result = bidi.getRunLevel(0);
    if (result != 1) {
        System.err.println("Incorrect run level: " + result);
        err = true;
    }

    if (err) {
        throw new RuntimeException("Failed.");
    }
}
 

/**
 * Handles the LTR and RTL direction of the given words. The whole implementation stands and falls with the given
 * word. If the word is a full line, the results will be the best. If the word contains of single words or
 * characters, the order of the characters in a word or words in a line may wrong, due to RTL and LTR marks and
 * characters!
 * 
 * Based on http://www.nesterovsky-bros.com/weblog/2013/07/28/VisualToLogicalConversionInJava.aspx
 * 
 * @param word The word that shall be processed
 * @return new word with the correct direction of the containing characters
 */
private String handleDirection(String word)
{
    Bidi bidi = new Bidi(word, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);

    // if there is pure LTR text no need to process further
    if (!bidi.isMixed() && bidi.getBaseLevel() == Bidi.DIRECTION_LEFT_TO_RIGHT)
    {
        return word;
    }
    
    // collect individual bidi information
    int runCount = bidi.getRunCount();
    byte[] levels = new byte[runCount];
    Integer[] runs = new Integer[runCount];
  
    for (int i = 0; i < runCount; i++)
    {
       levels[i] = (byte)bidi.getRunLevel(i);
       runs[i] = i;
    }

    // reorder individual parts based on their levels
    Bidi.reorderVisually(levels, 0, runs, 0, runCount);
    
    // collect the parts based on the direction within the run
    StringBuilder result = new StringBuilder();

    for (int i = 0; i < runCount; i++)
    {
       int index = runs[i];
       int start = bidi.getRunStart(index);
       int end = bidi.getRunLimit(index);

        int level = levels[index];

        if ((level & 1) != 0)
        {
            while (--end >= start)
            {
                char character = word.charAt(end);
                if (Character.isMirrored(word.codePointAt(end)))
                {
                    if (MIRRORING_CHAR_MAP.containsKey(character))
                    {
                        result.append(MIRRORING_CHAR_MAP.get(character));
                    }
                    else
                    {
                        result.append(character);
                    }
                }
                else
                {
                    result.append(character);
                }
            }
        }
        else
        {
            result.append(word, start, end);
        }
    }
    
    return result.toString();
}
 

private void testEachMethod(Bidi bidi,
                            String text,
                            String expectedLevels,
                            boolean expectedBaseIsLTR,
                            boolean expectedIsLTR,
                            boolean expectedIsRTL
                           ) {
    /* Test baseIsLeftToRight() */
    boolean actualBoolean = bidi.baseIsLeftToRight();
    checkResult("baseIsLeftToRight()", expectedBaseIsLTR, actualBoolean);

    /* Test getBaseLevel() */
    int expectedInt = (expectedBaseIsLTR) ? 0 : 1;
    int actualInt = bidi.getBaseLevel();
    checkResult("getBaseLevel()", expectedInt, actualInt);

    /* Test getLength() */
    expectedInt = text.length();
    actualInt = bidi.getLength();
    checkResult("getLength()", expectedInt, actualInt);

    /* Test getLevelAt() */
    sb.setLength(0);
    for (int i = 0; i < text.length(); i++) {
        sb.append(bidi.getLevelAt(i));
    }
    checkResult("getLevelAt()", expectedLevels, sb.toString());

    /* Test getRunCount() */
    expectedInt = getRunCount(expectedLevels);
    actualInt = bidi.getRunCount();
    checkResult("getRunCount()", expectedInt, actualInt);

    /* Test getRunLevel(), getRunLimit() and getRunStart() */
    if (expectedInt == actualInt) {
        int runCount = expectedInt;
        int[] expectedRunLevels = getRunLevels_int(runCount, expectedLevels);
        int[] expectedRunLimits = getRunLimits(runCount, expectedLevels);
        int[] expectedRunStarts = getRunStarts(runCount, expectedLevels);
        int[] actualRunLevels = new int[runCount];
        int[] actualRunLimits = new int[runCount];
        int[] actualRunStarts = new int[runCount];

        for (int k = 0; k < runCount; k++) {
            actualRunLevels[k] = bidi.getRunLevel(k);
            actualRunLimits[k] = bidi.getRunLimit(k);
            actualRunStarts[k] = bidi.getRunStart(k);
        }

        checkResult("getRunLevel()", expectedRunLevels, actualRunLevels);
        checkResult("getRunStart()", expectedRunStarts, actualRunStarts);
        checkResult("getRunLimit()", expectedRunLimits, actualRunLimits);
    }

    /* Test isLeftToRight() */
    boolean expectedBoolean = expectedIsLTR;
    actualBoolean = bidi.isLeftToRight();
    checkResult("isLeftToRight()", expectedBoolean, actualBoolean);

    /* Test isMixed() */
    expectedBoolean = !(expectedIsLTR || expectedIsRTL);
    actualBoolean = bidi.isMixed();
    checkResult("isMixed()", expectedBoolean, actualBoolean);

    /* Test isRightToLeft() */
    expectedBoolean = expectedIsRTL;
    actualBoolean = bidi.isRightToLeft();
    checkResult("isRightToLeft()", expectedBoolean, actualBoolean);
}
 

private void testEachMethod(Bidi bidi,
                            String text,
                            String expectedLevels,
                            boolean expectedBaseIsLTR,
                            boolean expectedIsLTR,
                            boolean expectedIsRTL
                           ) {
    /* Test baseIsLeftToRight() */
    boolean actualBoolean = bidi.baseIsLeftToRight();
    checkResult("baseIsLeftToRight()", expectedBaseIsLTR, actualBoolean);

    /* Test getBaseLevel() */
    int expectedInt = (expectedBaseIsLTR) ? 0 : 1;
    int actualInt = bidi.getBaseLevel();
    checkResult("getBaseLevel()", expectedInt, actualInt);

    /* Test getLength() */
    expectedInt = text.length();
    actualInt = bidi.getLength();
    checkResult("getLength()", expectedInt, actualInt);

    /* Test getLevelAt() */
    sb.setLength(0);
    for (int i = 0; i < text.length(); i++) {
        sb.append(bidi.getLevelAt(i));
    }
    checkResult("getLevelAt()", expectedLevels, sb.toString());

    /* Test getRunCount() */
    expectedInt = getRunCount(expectedLevels);
    actualInt = bidi.getRunCount();
    checkResult("getRunCount()", expectedInt, actualInt);

    /* Test getRunLevel(), getRunLimit() and getRunStart() */
    if (expectedInt == actualInt) {
        int runCount = expectedInt;
        int[] expectedRunLevels = getRunLevels_int(runCount, expectedLevels);
        int[] expectedRunLimits = getRunLimits(runCount, expectedLevels);
        int[] expectedRunStarts = getRunStarts(runCount, expectedLevels);
        int[] actualRunLevels = new int[runCount];
        int[] actualRunLimits = new int[runCount];
        int[] actualRunStarts = new int[runCount];

        for (int k = 0; k < runCount; k++) {
            actualRunLevels[k] = bidi.getRunLevel(k);
            actualRunLimits[k] = bidi.getRunLimit(k);
            actualRunStarts[k] = bidi.getRunStart(k);
        }

        checkResult("getRunLevel()", expectedRunLevels, actualRunLevels);
        checkResult("getRunStart()", expectedRunStarts, actualRunStarts);
        checkResult("getRunLimit()", expectedRunLimits, actualRunLimits);
    }

    /* Test isLeftToRight() */
    boolean expectedBoolean = expectedIsLTR;
    actualBoolean = bidi.isLeftToRight();
    checkResult("isLeftToRight()", expectedBoolean, actualBoolean);

    /* Test isMixed() */
    expectedBoolean = !(expectedIsLTR || expectedIsRTL);
    actualBoolean = bidi.isMixed();
    checkResult("isMixed()", expectedBoolean, actualBoolean);

    /* Test isRightToLeft() */
    expectedBoolean = expectedIsRTL;
    actualBoolean = bidi.isRightToLeft();
    checkResult("isRightToLeft()", expectedBoolean, actualBoolean);
}
 

private void testEachMethod(Bidi bidi,
                            String text,
                            String expectedLevels,
                            boolean expectedBaseIsLTR,
                            boolean expectedIsLTR,
                            boolean expectedIsRTL
                           ) {
    /* Test baseIsLeftToRight() */
    boolean actualBoolean = bidi.baseIsLeftToRight();
    checkResult("baseIsLeftToRight()", expectedBaseIsLTR, actualBoolean);

    /* Test getBaseLevel() */
    int expectedInt = (expectedBaseIsLTR) ? 0 : 1;
    int actualInt = bidi.getBaseLevel();
    checkResult("getBaseLevel()", expectedInt, actualInt);

    /* Test getLength() */
    expectedInt = text.length();
    actualInt = bidi.getLength();
    checkResult("getLength()", expectedInt, actualInt);

    /* Test getLevelAt() */
    sb.setLength(0);
    for (int i = 0; i < text.length(); i++) {
        sb.append(bidi.getLevelAt(i));
    }
    checkResult("getLevelAt()", expectedLevels, sb.toString());

    /* Test getRunCount() */
    expectedInt = getRunCount(expectedLevels);
    actualInt = bidi.getRunCount();
    checkResult("getRunCount()", expectedInt, actualInt);

    /* Test getRunLevel(), getRunLimit() and getRunStart() */
    if (expectedInt == actualInt) {
        int runCount = expectedInt;
        int[] expectedRunLevels = getRunLevels_int(runCount, expectedLevels);
        int[] expectedRunLimits = getRunLimits(runCount, expectedLevels);
        int[] expectedRunStarts = getRunStarts(runCount, expectedLevels);
        int[] actualRunLevels = new int[runCount];
        int[] actualRunLimits = new int[runCount];
        int[] actualRunStarts = new int[runCount];

        for (int k = 0; k < runCount; k++) {
            actualRunLevels[k] = bidi.getRunLevel(k);
            actualRunLimits[k] = bidi.getRunLimit(k);
            actualRunStarts[k] = bidi.getRunStart(k);
        }

        checkResult("getRunLevel()", expectedRunLevels, actualRunLevels);
        checkResult("getRunStart()", expectedRunStarts, actualRunStarts);
        checkResult("getRunLimit()", expectedRunLimits, actualRunLimits);
    }

    /* Test isLeftToRight() */
    boolean expectedBoolean = expectedIsLTR;
    actualBoolean = bidi.isLeftToRight();
    checkResult("isLeftToRight()", expectedBoolean, actualBoolean);

    /* Test isMixed() */
    expectedBoolean = !(expectedIsLTR || expectedIsRTL);
    actualBoolean = bidi.isMixed();
    checkResult("isMixed()", expectedBoolean, actualBoolean);

    /* Test isRightToLeft() */
    expectedBoolean = expectedIsRTL;
    actualBoolean = bidi.isRightToLeft();
    checkResult("isRightToLeft()", expectedBoolean, actualBoolean);
}