* LT RT TL TR * A B C C B A A D G G D A * D E F F E D B E H H E B * G H I I H G C F I I F C ** LT languages are most common (left-to-right lines, top-to-bottom). * This includes Western European languages, and optionally includes Japanese, * Chinese, and Korean. RT languages (right-to-left lines, * top-to-bottom) are mainly middle eastern, such as Hebrew and Arabic. * TR languages flow top-to-bottom in a line, right-to-left, and are * the basis of Japanese, Chinese, and Korean. Finally, TL languages * flow top-to-bottom in a line, left-to-right, as in Mongolian. * *
This is a pretty poor excuse for a type-safe enum, since it is not * guaranteed that orientation objects are unique (thanks to serialization), * yet there is no equals() method. You would be wise to compare the output * of isHorizontal() and isLeftToRight() rather than comparing objects with * ==, especially since more constants may be added in the future. * * @author Bryce McKinlay (bryce@albatross.co.nz) * @since 1.0 * @status updated to 1.4 */ public final class ComponentOrientation implements Serializable { /** * Compatible with JDK 1.0+. */ private static final long serialVersionUID = -4113291392143563828L; /** Constant for unknown orientation. */ private static final int UNKNOWN_ID = 1; /** Constant for horizontal line orientation. */ private static final int HORIZONTAL_ID = 2; /** Constant for left-to-right orientation. */ private static final int LEFT_TO_RIGHT_ID = 4; /** * Items run left to right, and lines flow top to bottom. Examples: English, * French. */ public static final ComponentOrientation LEFT_TO_RIGHT = new ComponentOrientation(HORIZONTAL_ID | LEFT_TO_RIGHT_ID); /** * Items run right to left, and lines flow top to bottom. Examples: Arabic, * Hebrew. */ public static final ComponentOrientation RIGHT_TO_LEFT = new ComponentOrientation(HORIZONTAL_ID); /** * The orientation is unknown for the locale. For backwards compatibility, * this behaves like LEFT_TO_RIGHT in the instance methods. */ public static final ComponentOrientation UNKNOWN = new ComponentOrientation(UNKNOWN_ID | HORIZONTAL_ID | LEFT_TO_RIGHT_ID); /** * The orientation of this object; bitwise-or of unknown (1), horizontal (2), * and left-to-right (4). * * @serial the orientation */ private final int orientation; /** * Construct a given orientation. * * @param orientation the orientation */ private ComponentOrientation(int orientation) { this.orientation = orientation; } /** * Returns true if the lines are horizontal, in which case lines flow * top-to-bottom. For example, English, Hebrew. Counterexamples: Japanese, * Chinese, Korean, Mongolian. * * @return true if this orientation has horizontal lines */ public boolean isHorizontal() { return (orientation & HORIZONTAL_ID) != 0; } /** * If isHorizontal() returns true, then this determines whether items in * the line flow left-to-right. If isHorizontal() returns false, items in * a line flow top-to-bottom, and this determines if lines flow * left-to-right. * * @return true if this orientation flows left-to-right */ public boolean isLeftToRight() { return (orientation & LEFT_TO_RIGHT_ID) != 0; } /** * Gets an orientation appropriate for the locale. * * @param locale the locale * @return the orientation for that locale * @throws NullPointerException if locale is null */ public static ComponentOrientation getOrientation(Locale locale) { // Based on iterating over all languages defined in JDK 1.4, this behavior // matches Sun's. However, it makes me wonder if any non-horizontal // orientations even exist, as it sure contradicts their documentation. String language = locale.getLanguage(); if ("ar".equals(language) || "fa".equals(language) || "iw".equals(language) || "ur".equals(language)) return RIGHT_TO_LEFT; return LEFT_TO_RIGHT; } /** * Gets an orientation from a resource bundle. This tries the following: * *