| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * (C) Copyright IBM Corp. 1999-2003 - All Rights Reserved |
| * |
| * The original version of this source code and documentation is |
| * copyrighted and owned by IBM. These materials are provided |
| * under terms of a License Agreement between IBM and Sun. |
| * This technology is protected by multiple US and International |
| * patents. This notice and attribution to IBM may not be removed. |
| */ |
| |
| package java.text; |
| |
| /** |
| * This class implements the Unicode Bidirectional Algorithm. |
| * <p> |
| * A Bidi object provides information on the bidirectional reordering of the text |
| * used to create it. This is required, for example, to properly display Arabic |
| * or Hebrew text. These languages are inherently mixed directional, as they order |
| * numbers from left-to-right while ordering most other text from right-to-left. |
| * <p> |
| * Once created, a Bidi object can be queried to see if the text it represents is |
| * all left-to-right or all right-to-left. Such objects are very lightweight and |
| * this text is relatively easy to process. |
| * <p> |
| * If there are multiple runs of text, information about the runs can be accessed |
| * by indexing to get the start, limit, and level of a run. The level represents |
| * both the direction and the 'nesting level' of a directional run. Odd levels |
| * are right-to-left, while even levels are left-to-right. So for example level |
| * 0 represents left-to-right text, while level 1 represents right-to-left text, and |
| * level 2 represents left-to-right text embedded in a right-to-left run. |
| * |
| * @since 1.4 |
| */ |
| public final class Bidi { |
| |
| /** Constant indicating base direction is left-to-right. */ |
| public static final int DIRECTION_LEFT_TO_RIGHT = 0; |
| |
| /** Constant indicating base direction is right-to-left. */ |
| public static final int DIRECTION_RIGHT_TO_LEFT = 1; |
| |
| /** |
| * 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. |
| */ |
| public static final int DIRECTION_DEFAULT_LEFT_TO_RIGHT = -2; |
| |
| /** |
| * 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. |
| */ |
| public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = -1; |
| |
| // Android-note: Upstream this class delegates to an internal implementation class BidiBase. |
| // For Android that is replaced with android.icu.text.Bidi. BidiBase and ICU Bidi work very |
| // similarly, but differ in some details like level of argument validation and how how exactly |
| // runs are counted. The majority of the changes in this file exist to allow for backwards |
| // compatibility with an earlier ICU4C based Bidi implementation. |
| |
| // BEGIN Android-added: translateConstToIcu(int). |
| private static int translateConstToIcu(int javaInt) { |
| switch (javaInt) { |
| case DIRECTION_DEFAULT_LEFT_TO_RIGHT: |
| return android.icu.text.Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT; |
| case DIRECTION_DEFAULT_RIGHT_TO_LEFT: |
| return android.icu.text.Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT; |
| case DIRECTION_LEFT_TO_RIGHT: |
| return android.icu.text.Bidi.DIRECTION_LEFT_TO_RIGHT; |
| case DIRECTION_RIGHT_TO_LEFT: |
| return android.icu.text.Bidi.DIRECTION_RIGHT_TO_LEFT; |
| // If the parameter was unrecognized use LEFT_TO_RIGHT. |
| default: |
| return android.icu.text.Bidi.DIRECTION_LEFT_TO_RIGHT; |
| } |
| } |
| // END Android-added: translateConstToIcu(int). |
| |
| // Android-changed: use ICU Bidi class instead of BidiBase. |
| private final android.icu.text.Bidi bidiBase; |
| |
| /** |
| * Create Bidi from the given paragraph of text and base direction. |
| * @param paragraph a paragraph of text |
| * @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. |
| */ |
| public Bidi(String paragraph, int flags) { |
| if (paragraph == null) { |
| throw new IllegalArgumentException("paragraph is null"); |
| } |
| |
| // Android-changed: use ICU Bidi class instead of BidiBase. |
| bidiBase = new android.icu.text.Bidi(paragraph.toCharArray(), 0, null, 0, |
| paragraph.length(), translateConstToIcu(flags)); |
| } |
| |
| /** |
| * Create Bidi from the given paragraph of text. |
| * <p> |
| * 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 computes 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. |
| * <p> |
| * 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. |
| * <p> |
| * 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. |
| * |
| * @param paragraph a paragraph of text with optional character and paragraph attribute information |
| * |
| * @see java.awt.font.TextAttribute#BIDI_EMBEDDING |
| * @see java.awt.font.TextAttribute#NUMERIC_SHAPING |
| * @see java.awt.font.TextAttribute#RUN_DIRECTION |
| */ |
| public Bidi(AttributedCharacterIterator paragraph) { |
| if (paragraph == null) { |
| throw new IllegalArgumentException("paragraph is null"); |
| } |
| |
| // Android-changed: change from BidiBase to ICU Bidi class. |
| this.bidiBase = new android.icu.text.Bidi(paragraph); |
| } |
| |
| /** |
| * 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. |
| * @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. |
| */ |
| public Bidi(char[] text, int textStart, byte[] embeddings, int embStart, int paragraphLength, int flags) { |
| if (text == null) { |
| throw new IllegalArgumentException("text is null"); |
| } |
| if (paragraphLength < 0) { |
| throw new IllegalArgumentException("bad length: " + paragraphLength); |
| } |
| if (textStart < 0 || paragraphLength > text.length - textStart) { |
| throw new IllegalArgumentException("bad range: " + textStart + |
| " length: " + paragraphLength + |
| " for text of length: " + text.length); |
| } |
| if (embeddings != null && (embStart < 0 || paragraphLength > embeddings.length - embStart)) { |
| throw new IllegalArgumentException("bad range: " + embStart + |
| " length: " + paragraphLength + |
| " for embeddings of length: " + text.length); |
| } |
| |
| // Android-changed: use ICU Bidi class instead of BidiBase. |
| bidiBase = new android.icu.text.Bidi(text, textStart, embeddings, embStart, |
| paragraphLength, translateConstToIcu(flags)); |
| } |
| |
| // Android-added: private constructor based on ICU Bidi object. |
| private Bidi(android.icu.text.Bidi bidiBase) { |
| this.bidiBase = bidiBase; |
| } |
| |
| /** |
| * Create a Bidi object representing the bidi information on a line of text within |
| * the paragraph represented by the current Bidi. This call is not required if the |
| * entire paragraph fits on one line. |
| * |
| * @param lineStart the offset from the start of the paragraph to the start of the line. |
| * @param lineLimit the offset from the start of the paragraph to the limit of the line. |
| * @return a {@code Bidi} object |
| */ |
| public Bidi createLineBidi(int lineStart, int lineLimit) { |
| // BEGIN Android-changed: add explict argument checks and use ICU Bidi class. |
| /* |
| AttributedString astr = new AttributedString(""); |
| Bidi newBidi = new Bidi(astr.getIterator()); |
| |
| return bidiBase.setLine(this, bidiBase, newBidi, newBidi.bidiBase, lineStart, lineLimit); |
| */ |
| if (lineStart < 0 || lineLimit < 0 || lineStart > lineLimit || lineLimit > getLength()) { |
| throw new IllegalArgumentException("Invalid ranges (start=" + lineStart + ", " + |
| "limit=" + lineLimit + ", length=" + getLength() + ")"); |
| } |
| |
| // In the special case where the start and end positions are the same, we return a new bidi |
| // instance which is empty. Note that the default constructor for an empty ICU4J bidi |
| // instance is not the same as passing in empty values. This way allows one to call |
| // .getLength() for example and return a correct value instead of an IllegalStateException |
| // being thrown, which happens in the case of using the empty constructor. |
| if (lineStart == lineLimit) { |
| return new Bidi(new android.icu.text.Bidi(new char[] {}, 0, new byte[] {}, 0, 0, |
| translateConstToIcu(DIRECTION_LEFT_TO_RIGHT))); |
| } |
| |
| return new Bidi(bidiBase.createLineBidi(lineStart, lineLimit)); |
| // END Android-changed: add explict argument checks and use ICU Bidi class. |
| } |
| |
| /** |
| * 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. |
| */ |
| public boolean isMixed() { |
| return bidiBase.isMixed(); |
| } |
| |
| /** |
| * 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 |
| */ |
| public boolean isLeftToRight() { |
| return bidiBase.isLeftToRight(); |
| } |
| |
| /** |
| * 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 |
| */ |
| public boolean isRightToLeft() { |
| return bidiBase.isRightToLeft(); |
| } |
| |
| /** |
| * Return the length of text in the line. |
| * @return the length of text in the line |
| */ |
| public int getLength() { |
| return bidiBase.getLength(); |
| } |
| |
| /** |
| * Return true if the base direction is left-to-right. |
| * @return true if the base direction is left-to-right |
| */ |
| public boolean baseIsLeftToRight() { |
| return bidiBase.baseIsLeftToRight(); |
| } |
| |
| /** |
| * Return the base level (0 if left-to-right, 1 if right-to-left). |
| * @return the base level |
| */ |
| public int getBaseLevel() { |
| return bidiBase.getParaLevel(); |
| } |
| |
| /** |
| * Return the resolved level of the character at offset. If offset is |
| * {@literal <} 0 or ≥ the length of the line, return the base direction |
| * level. |
| * |
| * @param offset the index of the character for which to return the level |
| * @return the resolved level of the character at offset |
| */ |
| public int getLevelAt(int offset) { |
| // BEGIN Android-changed: return base level on out of range offset argument. |
| try { |
| return bidiBase.getLevelAt(offset); |
| } catch (IllegalArgumentException e) { |
| return getBaseLevel(); |
| } |
| // END Android-changed: return base level on out of range offset argument. |
| } |
| |
| /** |
| * Return the number of level runs. |
| * @return the number of level runs |
| */ |
| public int getRunCount() { |
| // Android-changed: ICU treats the empty string as having 0 runs, we see it as 1 empty run. |
| int runCount = bidiBase.countRuns(); |
| return (runCount == 0 ? 1 : runCount); |
| } |
| |
| /** |
| * Return the level of the nth logical run in this line. |
| * @param run the index of the run, between 0 and {@code getRunCount()} |
| * @return the level of the run |
| */ |
| public int getRunLevel(int run) { |
| // Android-added: Tolerate calls with run == getRunCount() for backwards compatibility. |
| if (run == getRunCount()) { |
| return getBaseLevel(); |
| } |
| // Android-changed: ICU treats the empty string as having 0 runs, we see it as 1 empty run. |
| return (bidiBase.countRuns() == 0 ? bidiBase.getBaseLevel() : bidiBase.getRunLevel(run)); |
| } |
| |
| /** |
| * 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 {@code getRunCount()} |
| * @return the start of the run |
| */ |
| public int getRunStart(int run) { |
| // Android-added: Tolerate calls with run == getRunCount() for backwards compatibility. |
| if (run == getRunCount()) { |
| return getBaseLevel(); |
| } |
| // Android-changed: ICU treats the empty string as having 0 runs, we see it as 1 empty run. |
| return (bidiBase.countRuns() == 0 ? 0 : bidiBase.getRunStart(run)); |
| } |
| |
| /** |
| * 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 {@code getRunCount()} |
| * @return limit the limit of the run |
| */ |
| public int getRunLimit(int run) { |
| // Android-added: Tolerate calls with run == getRunCount() for backwards compatibility. |
| if (run == getRunCount()) { |
| return getBaseLevel(); |
| } |
| // Android-changed: ICU treats the empty string as having 0 runs, we see it as 1 empty run. |
| return (bidiBase.countRuns() == 0 ? bidiBase.getLength() : bidiBase.getRunLimit(run)); |
| } |
| |
| /** |
| * 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 function 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 |
| */ |
| public static boolean requiresBidi(char[] text, int start, int limit) { |
| // Android-added: Check arguments to throw correct exception. |
| if (0 > start || start > limit || limit > text.length) { |
| throw new IllegalArgumentException("Value start " + start + |
| " is out of range 0 to " + limit); |
| } |
| return android.icu.text.Bidi.requiresBidi(text, start, limit); |
| } |
| |
| /** |
| * Reorder the objects in the array into visual order based on their levels. |
| * This is a utility function 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 {@code index} from |
| * {@code objectStart} up to {@code 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 {@code 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 |
| */ |
| public static void reorderVisually(byte[] levels, int levelStart, Object[] objects, int objectStart, int count) { |
| // BEGIN Android-added: Check arguments to throw correct exception. |
| 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)); |
| } |
| // END Android-added: Check arguments to throw correct exception. |
| |
| // Android-changed: use ICU Bidi class instead of BidiBase. |
| android.icu.text.Bidi.reorderVisually(levels, levelStart, objects, objectStart, count); |
| } |
| |
| /** |
| * Display the bidi internal state, used in debugging. |
| */ |
| public String toString() { |
| // Android-changed: construct String representation from ICU Bidi object values. |
| return getClass().getName() |
| + "[direction: " + bidiBase.getDirection() + " baseLevel: " + bidiBase.getBaseLevel() |
| + " length: " + bidiBase.getLength() + " runs: " + bidiBase.getRunCount() + "]"; |
| } |
| |
| } |
