Java tutorial
/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.text; import android.view.View; import java.nio.CharBuffer; /** * Some objects that implement {@link TextDirectionHeuristic}. Use these with * the {@link BidiFormatter#unicodeWrap unicodeWrap()} methods in {@link BidiFormatter}. * Also notice that these direction heuristics correspond to the same types of constants * provided in the {@link android.view.View} class for {@link android.view.View#setTextDirection * setTextDirection()}, such as {@link android.view.View#TEXT_DIRECTION_RTL}. * <p>To support versions lower than {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR2}, * you can use the support library's {@link android.support.v4.text.TextDirectionHeuristicsCompat} * class. * */ public class TextDirectionHeuristics { /** * Always decides that the direction is left to right. */ public static final TextDirectionHeuristic LTR = new TextDirectionHeuristicInternal(null /* no algorithm */, false); /** * Always decides that the direction is right to left. */ public static final TextDirectionHeuristic RTL = new TextDirectionHeuristicInternal(null /* no algorithm */, true); /** * Determines the direction based on the first strong directional character, including bidi * format chars, falling back to left to right if it finds none. This is the default behavior * of the Unicode Bidirectional Algorithm. */ public static final TextDirectionHeuristic FIRSTSTRONG_LTR = new TextDirectionHeuristicInternal( FirstStrong.INSTANCE, false); /** * Determines the direction based on the first strong directional character, including bidi * format chars, falling back to right to left if it finds none. This is similar to the default * behavior of the Unicode Bidirectional Algorithm, just with different fallback behavior. */ public static final TextDirectionHeuristic FIRSTSTRONG_RTL = new TextDirectionHeuristicInternal( FirstStrong.INSTANCE, true); /** * If the text contains any strong right to left non-format character, determines that the * direction is right to left, falling back to left to right if it finds none. */ public static final TextDirectionHeuristic ANYRTL_LTR = new TextDirectionHeuristicInternal( AnyStrong.INSTANCE_RTL, false); /** * Force the paragraph direction to the Locale direction. Falls back to left to right. */ public static final TextDirectionHeuristic LOCALE = TextDirectionHeuristicLocale.INSTANCE; /** * State constants for taking care about true / false / unknown */ private static final int STATE_TRUE = 0; private static final int STATE_FALSE = 1; private static final int STATE_UNKNOWN = 2; /* Returns STATE_TRUE for strong RTL characters, STATE_FALSE for strong LTR characters, and * STATE_UNKNOWN for everything else. */ private static int isRtlCodePoint(int codePoint) { switch (Character.getDirectionality(codePoint)) { case Character.DIRECTIONALITY_LEFT_TO_RIGHT: return STATE_FALSE; case Character.DIRECTIONALITY_RIGHT_TO_LEFT: case Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: return STATE_TRUE; case Character.DIRECTIONALITY_UNDEFINED: // Unassigned characters still have bidi direction, defined at: // http://www.unicode.org/Public/UCD/latest/ucd/extracted/DerivedBidiClass.txt if ((0x0590 <= codePoint && codePoint <= 0x08FF) || (0xFB1D <= codePoint && codePoint <= 0xFDCF) || (0xFDF0 <= codePoint && codePoint <= 0xFDFF) || (0xFE70 <= codePoint && codePoint <= 0xFEFF) || (0x10800 <= codePoint && codePoint <= 0x10FFF) || (0x1E800 <= codePoint && codePoint <= 0x1EFFF)) { // Unassigned RTL character return STATE_TRUE; } else if ( // Potentially-unassigned Default_Ignorable. Ranges are from unassigned // characters that have Unicode property Other_Default_Ignorable_Code_Point // plus some enlargening to cover bidi isolates and simplify checks. (0x2065 <= codePoint && codePoint <= 0x2069) || (0xFFF0 <= codePoint && codePoint <= 0xFFF8) || (0xE0000 <= codePoint && codePoint <= 0xE0FFF) || // Non-character (0xFDD0 <= codePoint && codePoint <= 0xFDEF) || ((codePoint & 0xFFFE) == 0xFFFE) || // Currency symbol (0x20A0 <= codePoint && codePoint <= 0x20CF) || // Unpaired surrogate (0xD800 <= codePoint && codePoint <= 0xDFFF)) { return STATE_UNKNOWN; } else { // Unassigned LTR character return STATE_FALSE; } default: return STATE_UNKNOWN; } } /** * Computes the text direction based on an algorithm. Subclasses implement * {@link #defaultIsRtl} to handle cases where the algorithm cannot determine the * direction from the text alone. */ private static abstract class TextDirectionHeuristicImpl implements TextDirectionHeuristic { private final TextDirectionAlgorithm mAlgorithm; public TextDirectionHeuristicImpl(TextDirectionAlgorithm algorithm) { mAlgorithm = algorithm; } /** * Return true if the default text direction is rtl. */ abstract protected boolean defaultIsRtl(); @Override public boolean isRtl(char[] array, int start, int count) { return isRtl(CharBuffer.wrap(array), start, count); } @Override public boolean isRtl(CharSequence cs, int start, int count) { if (cs == null || start < 0 || count < 0 || cs.length() - count < start) { throw new IllegalArgumentException(); } if (mAlgorithm == null) { return defaultIsRtl(); } return doCheck(cs, start, count); } private boolean doCheck(CharSequence cs, int start, int count) { switch (mAlgorithm.checkRtl(cs, start, count)) { case STATE_TRUE: return true; case STATE_FALSE: return false; default: return defaultIsRtl(); } } } private static class TextDirectionHeuristicInternal extends TextDirectionHeuristicImpl { private final boolean mDefaultIsRtl; private TextDirectionHeuristicInternal(TextDirectionAlgorithm algorithm, boolean defaultIsRtl) { super(algorithm); mDefaultIsRtl = defaultIsRtl; } @Override protected boolean defaultIsRtl() { return mDefaultIsRtl; } } /** * Interface for an algorithm to guess the direction of a paragraph of text. */ private static interface TextDirectionAlgorithm { /** * Returns whether the range of text is RTL according to the algorithm. */ int checkRtl(CharSequence cs, int start, int count); } /** * Algorithm that uses the first strong directional character to determine the paragraph * direction. This is the standard Unicode Bidirectional Algorithm (steps P2 and P3), with the * exception that if no strong character is found, UNKNOWN is returned. */ private static class FirstStrong implements TextDirectionAlgorithm { @Override public int checkRtl(CharSequence cs, int start, int count) { int result = STATE_UNKNOWN; int openIsolateCount = 0; for (int cp, i = start, end = start + count; i < end && result == STATE_UNKNOWN; i += Character.charCount(cp)) { cp = Character.codePointAt(cs, i); if (0x2066 <= cp && cp <= 0x2068) { // Opening isolates openIsolateCount += 1; } else if (cp == 0x2069) { // POP DIRECTIONAL ISOLATE (PDI) if (openIsolateCount > 0) openIsolateCount -= 1; } else if (openIsolateCount == 0) { // Only consider the characters outside isolate pairs result = isRtlCodePoint(cp); } } return result; } private FirstStrong() { } public static final FirstStrong INSTANCE = new FirstStrong(); } /** * Algorithm that uses the presence of any strong directional character of the type indicated * in the constructor parameter to determine the direction of text. * * Characters inside isolate pairs are skipped. */ private static class AnyStrong implements TextDirectionAlgorithm { private final boolean mLookForRtl; @Override public int checkRtl(CharSequence cs, int start, int count) { boolean haveUnlookedFor = false; int openIsolateCount = 0; for (int cp, i = start, end = start + count; i < end; i += Character.charCount(cp)) { cp = Character.codePointAt(cs, i); if (0x2066 <= cp && cp <= 0x2068) { // Opening isolates openIsolateCount += 1; } else if (cp == 0x2069) { // POP DIRECTIONAL ISOLATE (PDI) if (openIsolateCount > 0) openIsolateCount -= 1; } else if (openIsolateCount == 0) { // Only consider the characters outside isolate pairs switch (isRtlCodePoint(cp)) { case STATE_TRUE: if (mLookForRtl) { return STATE_TRUE; } haveUnlookedFor = true; break; case STATE_FALSE: if (!mLookForRtl) { return STATE_FALSE; } haveUnlookedFor = true; break; default: break; } } } if (haveUnlookedFor) { return mLookForRtl ? STATE_FALSE : STATE_TRUE; } return STATE_UNKNOWN; } private AnyStrong(boolean lookForRtl) { this.mLookForRtl = lookForRtl; } public static final AnyStrong INSTANCE_RTL = new AnyStrong(true); public static final AnyStrong INSTANCE_LTR = new AnyStrong(false); } /** * Algorithm that uses the Locale direction to force the direction of a paragraph. */ private static class TextDirectionHeuristicLocale extends TextDirectionHeuristicImpl { public TextDirectionHeuristicLocale() { super(null); } @Override protected boolean defaultIsRtl() { final int dir = TextUtils.getLayoutDirectionFromLocale(java.util.Locale.getDefault()); return (dir == View.LAYOUT_DIRECTION_RTL); } public static final TextDirectionHeuristicLocale INSTANCE = new TextDirectionHeuristicLocale(); } }