|
1 /* |
|
2 * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Sun designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Sun in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
22 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
23 * have any questions. |
|
24 */ |
|
25 |
|
26 /* |
|
27 * (C) Copyright IBM Corp. 1998 - All Rights Reserved |
|
28 * |
|
29 * The original version of this source code and documentation is copyrighted |
|
30 * and owned by IBM, Inc. These materials are provided under terms of a |
|
31 * License Agreement between IBM and Sun. This technology is protected by |
|
32 * multiple US and International patents. This notice and attribution to IBM |
|
33 * may not be removed. |
|
34 * |
|
35 */ |
|
36 |
|
37 package java.awt; |
|
38 |
|
39 import java.util.Locale; |
|
40 import java.util.ResourceBundle; |
|
41 |
|
42 /** |
|
43 * The ComponentOrientation class encapsulates the language-sensitive |
|
44 * orientation that is to be used to order the elements of a component |
|
45 * or of text. It is used to reflect the differences in this ordering |
|
46 * between Western alphabets, Middle Eastern (such as Hebrew), and Far |
|
47 * Eastern (such as Japanese). |
|
48 * <p> |
|
49 * Fundamentally, this governs items (such as characters) which are laid out |
|
50 * in lines, with the lines then laid out in a block. This also applies |
|
51 * to items in a widget: for example, in a check box where the box is |
|
52 * positioned relative to the text. |
|
53 * <p> |
|
54 * There are four different orientations used in modern languages |
|
55 * as in the following table.<br> |
|
56 * <pre> |
|
57 * LT RT TL TR |
|
58 * A B C C B A A D G G D A |
|
59 * D E F F E D B E H H E B |
|
60 * G H I I H G C F I I F C |
|
61 * </pre><br> |
|
62 * (In the header, the two-letter abbreviation represents the item direction |
|
63 * in the first letter, and the line direction in the second. For example, |
|
64 * LT means "items left-to-right, lines top-to-bottom", |
|
65 * TL means "items top-to-bottom, lines left-to-right", and so on.) |
|
66 * <p> |
|
67 * The orientations are: |
|
68 * <ul> |
|
69 * <li>LT - Western Europe (optional for Japanese, Chinese, Korean) |
|
70 * <li>RT - Middle East (Arabic, Hebrew) |
|
71 * <li>TR - Japanese, Chinese, Korean |
|
72 * <li>TL - Mongolian |
|
73 * </ul> |
|
74 * Components whose view and controller code depends on orientation |
|
75 * should use the <code>isLeftToRight()</code> and |
|
76 * <code>isHorizontal()</code> methods to |
|
77 * determine their behavior. They should not include switch-like |
|
78 * code that keys off of the constants, such as: |
|
79 * <pre> |
|
80 * if (orientation == LEFT_TO_RIGHT) { |
|
81 * ... |
|
82 * } else if (orientation == RIGHT_TO_LEFT) { |
|
83 * ... |
|
84 * } else { |
|
85 * // Oops |
|
86 * } |
|
87 * </pre> |
|
88 * This is unsafe, since more constants may be added in the future and |
|
89 * since it is not guaranteed that orientation objects will be unique. |
|
90 */ |
|
91 public final class ComponentOrientation implements java.io.Serializable |
|
92 { |
|
93 /* |
|
94 * serialVersionUID |
|
95 */ |
|
96 private static final long serialVersionUID = -4113291392143563828L; |
|
97 |
|
98 // Internal constants used in the implementation |
|
99 private static final int UNK_BIT = 1; |
|
100 private static final int HORIZ_BIT = 2; |
|
101 private static final int LTR_BIT = 4; |
|
102 |
|
103 /** |
|
104 * Items run left to right and lines flow top to bottom |
|
105 * Examples: English, French. |
|
106 */ |
|
107 public static final ComponentOrientation LEFT_TO_RIGHT = |
|
108 new ComponentOrientation(HORIZ_BIT|LTR_BIT); |
|
109 |
|
110 /** |
|
111 * Items run right to left and lines flow top to bottom |
|
112 * Examples: Arabic, Hebrew. |
|
113 */ |
|
114 public static final ComponentOrientation RIGHT_TO_LEFT = |
|
115 new ComponentOrientation(HORIZ_BIT); |
|
116 |
|
117 /** |
|
118 * Indicates that a component's orientation has not been set. |
|
119 * To preserve the behavior of existing applications, |
|
120 * isLeftToRight will return true for this value. |
|
121 */ |
|
122 public static final ComponentOrientation UNKNOWN = |
|
123 new ComponentOrientation(HORIZ_BIT|LTR_BIT|UNK_BIT); |
|
124 |
|
125 /** |
|
126 * Are lines horizontal? |
|
127 * This will return true for horizontal, left-to-right writing |
|
128 * systems such as Roman. |
|
129 */ |
|
130 public boolean isHorizontal() { |
|
131 return (orientation & HORIZ_BIT) != 0; |
|
132 } |
|
133 |
|
134 /** |
|
135 * HorizontalLines: Do items run left-to-right?<br> |
|
136 * Vertical Lines: Do lines run left-to-right?<br> |
|
137 * This will return true for horizontal, left-to-right writing |
|
138 * systems such as Roman. |
|
139 */ |
|
140 public boolean isLeftToRight() { |
|
141 return (orientation & LTR_BIT) != 0; |
|
142 } |
|
143 |
|
144 /** |
|
145 * Returns the orientation that is appropriate for the given locale. |
|
146 * @param locale the specified locale |
|
147 */ |
|
148 public static ComponentOrientation getOrientation(Locale locale) { |
|
149 // A more flexible implementation would consult a ResourceBundle |
|
150 // to find the appropriate orientation. Until pluggable locales |
|
151 // are introduced however, the flexiblity isn't really needed. |
|
152 // So we choose efficiency instead. |
|
153 String lang = locale.getLanguage(); |
|
154 if( "iw".equals(lang) || "ar".equals(lang) |
|
155 || "fa".equals(lang) || "ur".equals(lang) ) |
|
156 { |
|
157 return RIGHT_TO_LEFT; |
|
158 } else { |
|
159 return LEFT_TO_RIGHT; |
|
160 } |
|
161 } |
|
162 |
|
163 /** |
|
164 * Returns the orientation appropriate for the given ResourceBundle's |
|
165 * localization. Three approaches are tried, in the following order: |
|
166 * <ol> |
|
167 * <li>Retrieve a ComponentOrientation object from the ResourceBundle |
|
168 * using the string "Orientation" as the key. |
|
169 * <li>Use the ResourceBundle.getLocale to determine the bundle's |
|
170 * locale, then return the orientation for that locale. |
|
171 * <li>Return the default locale's orientation. |
|
172 * </ol> |
|
173 * |
|
174 * @deprecated As of J2SE 1.4, use {@link #getOrientation(java.util.Locale)}. |
|
175 */ |
|
176 @Deprecated |
|
177 public static ComponentOrientation getOrientation(ResourceBundle bdl) |
|
178 { |
|
179 ComponentOrientation result = null; |
|
180 |
|
181 try { |
|
182 result = (ComponentOrientation)bdl.getObject("Orientation"); |
|
183 } |
|
184 catch (Exception e) { |
|
185 } |
|
186 |
|
187 if (result == null) { |
|
188 result = getOrientation(bdl.getLocale()); |
|
189 } |
|
190 if (result == null) { |
|
191 result = getOrientation(Locale.getDefault()); |
|
192 } |
|
193 return result; |
|
194 } |
|
195 |
|
196 private int orientation; |
|
197 |
|
198 private ComponentOrientation(int value) |
|
199 { |
|
200 orientation = value; |
|
201 } |
|
202 } |