/*
* Copyright (c) 1998, 2006, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* (C) Copyright IBM Corp. 1998 - All Rights Reserved
*
* The original version of this source code and documentation is copyrighted
* and owned by IBM, Inc. These materials are provided under terms of a
* License Agreement between IBM and Sun. This technology is protected by
* multiple US and International patents. This notice and attribution to IBM
* may not be removed.
*
*/
package java.awt;
import java.util.Locale;
import java.util.ResourceBundle;
/**
* The ComponentOrientation class encapsulates the language-sensitive
* orientation that is to be used to order the elements of a component
* or of text. It is used to reflect the differences in this ordering
* between Western alphabets, Middle Eastern (such as Hebrew), and Far
* Eastern (such as Japanese).
* <p>
* Fundamentally, this governs items (such as characters) which are laid out
* in lines, with the lines then laid out in a block. This also applies
* to items in a widget: for example, in a check box where the box is
* positioned relative to the text.
* <p>
* There are four different orientations used in modern languages
* as in the following table.<br>
* <pre>
* 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
* </pre><br>
* (In the header, the two-letter abbreviation represents the item direction
* in the first letter, and the line direction in the second. For example,
* LT means "items left-to-right, lines top-to-bottom",
* TL means "items top-to-bottom, lines left-to-right", and so on.)
* <p>
* The orientations are:
* <ul>
* <li>LT - Western Europe (optional for Japanese, Chinese, Korean)
* <li>RT - Middle East (Arabic, Hebrew)
* <li>TR - Japanese, Chinese, Korean
* <li>TL - Mongolian
* </ul>
* Components whose view and controller code depends on orientation
* should use the <code>isLeftToRight()</code> and
* <code>isHorizontal()</code> methods to
* determine their behavior. They should not include switch-like
* code that keys off of the constants, such as:
* <pre>
* if (orientation == LEFT_TO_RIGHT) {
* ...
* } else if (orientation == RIGHT_TO_LEFT) {
* ...
* } else {
* // Oops
* }
* </pre>
* This is unsafe, since more constants may be added in the future and
* since it is not guaranteed that orientation objects will be unique.
*/
public final class ComponentOrientation implements java.io.Serializable
{
/*
* serialVersionUID
*/
private static final long serialVersionUID = -4113291392143563828L;
// Internal constants used in the implementation
private static final int UNK_BIT = 1;
private static final int HORIZ_BIT = 2;
private static final int LTR_BIT = 4;
/**
* Items run left to right and lines flow top to bottom
* Examples: English, French.
*/
public static final ComponentOrientation LEFT_TO_RIGHT =
new ComponentOrientation(HORIZ_BIT|LTR_BIT);
/**
* Items run right to left and lines flow top to bottom
* Examples: Arabic, Hebrew.
*/
public static final ComponentOrientation RIGHT_TO_LEFT =
new ComponentOrientation(HORIZ_BIT);
/**
* Indicates that a component's orientation has not been set.
* To preserve the behavior of existing applications,
* isLeftToRight will return true for this value.
*/
public static final ComponentOrientation UNKNOWN =
new ComponentOrientation(HORIZ_BIT|LTR_BIT|UNK_BIT);
/**
* Are lines horizontal?
* This will return true for horizontal, left-to-right writing
* systems such as Roman.
*/
public boolean isHorizontal() {
return (orientation & HORIZ_BIT) != 0;
}
/**
* HorizontalLines: Do items run left-to-right?<br>
* Vertical Lines: Do lines run left-to-right?<br>
* This will return true for horizontal, left-to-right writing
* systems such as Roman.
*/
public boolean isLeftToRight() {
return (orientation & LTR_BIT) != 0;
}
/**
* Returns the orientation that is appropriate for the given locale.
* @param locale the specified locale
*/
public static ComponentOrientation getOrientation(Locale locale) {
// A more flexible implementation would consult a ResourceBundle
// to find the appropriate orientation. Until pluggable locales
// are introduced however, the flexiblity isn't really needed.
// So we choose efficiency instead.
String lang = locale.getLanguage();
if( "iw".equals(lang) || "ar".equals(lang)
|| "fa".equals(lang) || "ur".equals(lang) )
{
return RIGHT_TO_LEFT;
} else {
return LEFT_TO_RIGHT;
}
}
/**
* Returns the orientation appropriate for the given ResourceBundle's
* localization. Three approaches are tried, in the following order:
* <ol>
* <li>Retrieve a ComponentOrientation object from the ResourceBundle
* using the string "Orientation" as the key.
* <li>Use the ResourceBundle.getLocale to determine the bundle's
* locale, then return the orientation for that locale.
* <li>Return the default locale's orientation.
* </ol>
*
* @deprecated As of J2SE 1.4, use {@link #getOrientation(java.util.Locale)}.
*/
@Deprecated
public static ComponentOrientation getOrientation(ResourceBundle bdl)
{
ComponentOrientation result = null;
try {
result = (ComponentOrientation)bdl.getObject("Orientation");
}
catch (Exception e) {
}
if (result == null) {
result = getOrientation(bdl.getLocale());
}
if (result == null) {
result = getOrientation(Locale.getDefault());
}
return result;
}
private int orientation;
private ComponentOrientation(int value)
{
orientation = value;
}
}