View Javadoc
1   /*
2    * Copyright (c) 1998, 2006, Oracle and/or its affiliates. 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.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * 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  }