001: /*
002: * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: /*
027: * (C) Copyright IBM Corp. 1998 - All Rights Reserved
028: *
029: * The original version of this source code and documentation is copyrighted
030: * and owned by IBM, Inc. These materials are provided under terms of a
031: * License Agreement between IBM and Sun. This technology is protected by
032: * multiple US and International patents. This notice and attribution to IBM
033: * may not be removed.
034: *
035: */
036:
037: package java.awt;
038:
039: import java.util.Locale;
040: import java.util.ResourceBundle;
041:
042: /**
043: * The ComponentOrientation class encapsulates the language-sensitive
044: * orientation that is to be used to order the elements of a component
045: * or of text. It is used to reflect the differences in this ordering
046: * between Western alphabets, Middle Eastern (such as Hebrew), and Far
047: * Eastern (such as Japanese).
048: * <p>
049: * Fundamentally, this governs items (such as characters) which are laid out
050: * in lines, with the lines then laid out in a block. This also applies
051: * to items in a widget: for example, in a check box where the box is
052: * positioned relative to the text.
053: * <p>
054: * There are four different orientations used in modern languages
055: * as in the following table.<br>
056: * <pre>
057: * LT RT TL TR
058: * A B C C B A A D G G D A
059: * D E F F E D B E H H E B
060: * G H I I H G C F I I F C
061: * </pre><br>
062: * (In the header, the two-letter abbreviation represents the item direction
063: * in the first letter, and the line direction in the second. For example,
064: * LT means "items left-to-right, lines top-to-bottom",
065: * TL means "items top-to-bottom, lines left-to-right", and so on.)
066: * <p>
067: * The orientations are:
068: * <ul>
069: * <li>LT - Western Europe (optional for Japanese, Chinese, Korean)
070: * <li>RT - Middle East (Arabic, Hebrew)
071: * <li>TR - Japanese, Chinese, Korean
072: * <li>TL - Mongolian
073: * </ul>
074: * Components whose view and controller code depends on orientation
075: * should use the <code>isLeftToRight()</code> and
076: * <code>isHorizontal()</code> methods to
077: * determine their behavior. They should not include switch-like
078: * code that keys off of the constants, such as:
079: * <pre>
080: * if (orientation == LEFT_TO_RIGHT) {
081: * ...
082: * } else if (orientation == RIGHT_TO_LEFT) {
083: * ...
084: * } else {
085: * // Oops
086: * }
087: * </pre>
088: * This is unsafe, since more constants may be added in the future and
089: * since it is not guaranteed that orientation objects will be unique.
090: */
091: public final class ComponentOrientation implements java.io.Serializable {
092: /*
093: * serialVersionUID
094: */
095: private static final long serialVersionUID = -4113291392143563828L;
096:
097: // Internal constants used in the implementation
098: private static final int UNK_BIT = 1;
099: private static final int HORIZ_BIT = 2;
100: private static final int LTR_BIT = 4;
101:
102: /**
103: * Items run left to right and lines flow top to bottom
104: * Examples: English, French.
105: */
106: public static final ComponentOrientation LEFT_TO_RIGHT = new ComponentOrientation(
107: HORIZ_BIT | LTR_BIT);
108:
109: /**
110: * Items run right to left and lines flow top to bottom
111: * Examples: Arabic, Hebrew.
112: */
113: public static final ComponentOrientation RIGHT_TO_LEFT = new ComponentOrientation(
114: HORIZ_BIT);
115:
116: /**
117: * Indicates that a component's orientation has not been set.
118: * To preserve the behavior of existing applications,
119: * isLeftToRight will return true for this value.
120: */
121: public static final ComponentOrientation UNKNOWN = new ComponentOrientation(
122: HORIZ_BIT | LTR_BIT | UNK_BIT);
123:
124: /**
125: * Are lines horizontal?
126: * This will return true for horizontal, left-to-right writing
127: * systems such as Roman.
128: */
129: public boolean isHorizontal() {
130: return (orientation & HORIZ_BIT) != 0;
131: }
132:
133: /**
134: * HorizontalLines: Do items run left-to-right?<br>
135: * Vertical Lines: Do lines run left-to-right?<br>
136: * This will return true for horizontal, left-to-right writing
137: * systems such as Roman.
138: */
139: public boolean isLeftToRight() {
140: return (orientation & LTR_BIT) != 0;
141: }
142:
143: /**
144: * Returns the orientation that is appropriate for the given locale.
145: * @param locale the specified locale
146: */
147: public static ComponentOrientation getOrientation(Locale locale) {
148: // A more flexible implementation would consult a ResourceBundle
149: // to find the appropriate orientation. Until pluggable locales
150: // are introduced however, the flexiblity isn't really needed.
151: // So we choose efficiency instead.
152: String lang = locale.getLanguage();
153: if ("iw".equals(lang) || "ar".equals(lang) || "fa".equals(lang)
154: || "ur".equals(lang)) {
155: return RIGHT_TO_LEFT;
156: } else {
157: return LEFT_TO_RIGHT;
158: }
159: }
160:
161: /**
162: * Returns the orientation appropriate for the given ResourceBundle's
163: * localization. Three approaches are tried, in the following order:
164: * <ol>
165: * <li>Retrieve a ComponentOrientation object from the ResourceBundle
166: * using the string "Orientation" as the key.
167: * <li>Use the ResourceBundle.getLocale to determine the bundle's
168: * locale, then return the orientation for that locale.
169: * <li>Return the default locale's orientation.
170: * </ol>
171: *
172: * @deprecated As of J2SE 1.4, use {@link #getOrientation(java.util.Locale)}.
173: */
174: @Deprecated
175: public static ComponentOrientation getOrientation(ResourceBundle bdl) {
176: ComponentOrientation result = null;
177:
178: try {
179: result = (ComponentOrientation) bdl
180: .getObject("Orientation");
181: } catch (Exception e) {
182: }
183:
184: if (result == null) {
185: result = getOrientation(bdl.getLocale());
186: }
187: if (result == null) {
188: result = getOrientation(Locale.getDefault());
189: }
190: return result;
191: }
192:
193: private int orientation;
194:
195: private ComponentOrientation(int value) {
196: orientation = value;
197: }
198: }
| 