/*

 * 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;

    }

 }