| /* |
| * Copyright (c) 1997, 2004, 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. |
| */ |
| |
| package javax.accessibility; |
| |
| import java.util.Vector; |
| import java.util.Locale; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| |
| /** |
| * <P>Class AccessibleState describes a component's particular state. The actual |
| * state of the component is defined as an AccessibleStateSet, which is a |
| * composed set of AccessibleStates. |
| * <p>The toDisplayString method allows you to obtain the localized string |
| * for a locale independent key from a predefined ResourceBundle for the |
| * keys defined in this class. |
| * <p>The constants in this class present a strongly typed enumeration |
| * of common object roles. A public constructor for this class has been |
| * purposely omitted and applications should use one of the constants |
| * from this class. If the constants in this class are not sufficient |
| * to describe the role of an object, a subclass should be generated |
| * from this class and it should provide constants in a similar manner. |
| * |
| * @author Willie Walker |
| * @author Peter Korn |
| */ |
| public class AccessibleState extends AccessibleBundle { |
| |
| // If you add or remove anything from here, make sure you |
| // update AccessibleResourceBundle.java. |
| |
| /** |
| * Indicates a window is currently the active window. This includes |
| * windows, dialogs, frames, etc. In addition, this state is used |
| * to indicate the currently active child of a component such as a |
| * list, table, or tree. For example, the active child of a list |
| * is the child that is drawn with a rectangle around it. |
| * @see AccessibleRole#WINDOW |
| * @see AccessibleRole#FRAME |
| * @see AccessibleRole#DIALOG |
| */ |
| public static final AccessibleState ACTIVE |
| = new AccessibleState("active"); |
| |
| /** |
| * Indicates this object is currently pressed. This is usually |
| * associated with buttons and indicates the user has pressed a |
| * mouse button while the pointer was over the button and has |
| * not yet released the mouse button. |
| * @see AccessibleRole#PUSH_BUTTON |
| */ |
| public static final AccessibleState PRESSED |
| = new AccessibleState("pressed"); |
| |
| /** |
| * Indicates that the object is armed. This is usually used on buttons |
| * that have been pressed but not yet released, and the mouse pointer |
| * is still over the button. |
| * @see AccessibleRole#PUSH_BUTTON |
| */ |
| public static final AccessibleState ARMED |
| = new AccessibleState("armed"); |
| |
| /** |
| * Indicates the current object is busy. This is usually used on objects |
| * such as progress bars, sliders, or scroll bars to indicate they are |
| * in a state of transition. |
| * @see AccessibleRole#PROGRESS_BAR |
| * @see AccessibleRole#SCROLL_BAR |
| * @see AccessibleRole#SLIDER |
| */ |
| public static final AccessibleState BUSY |
| = new AccessibleState("busy"); |
| |
| /** |
| * Indicates this object is currently checked. This is usually used on |
| * objects such as toggle buttons, radio buttons, and check boxes. |
| * @see AccessibleRole#TOGGLE_BUTTON |
| * @see AccessibleRole#RADIO_BUTTON |
| * @see AccessibleRole#CHECK_BOX |
| */ |
| public static final AccessibleState CHECKED |
| = new AccessibleState("checked"); |
| |
| /** |
| * Indicates the user can change the contents of this object. This |
| * is usually used primarily for objects that allow the user to |
| * enter text. Other objects, such as scroll bars and sliders, |
| * are automatically editable if they are enabled. |
| * @see #ENABLED |
| */ |
| public static final AccessibleState EDITABLE |
| = new AccessibleState("editable"); |
| |
| /** |
| * Indicates this object allows progressive disclosure of its children. |
| * This is usually used with hierarchical objects such as trees and |
| * is often paired with the EXPANDED or COLLAPSED states. |
| * @see #EXPANDED |
| * @see #COLLAPSED |
| * @see AccessibleRole#TREE |
| */ |
| public static final AccessibleState EXPANDABLE |
| = new AccessibleState("expandable"); |
| |
| /** |
| * Indicates this object is collapsed. This is usually paired with the |
| * EXPANDABLE state and is used on objects that provide progressive |
| * disclosure such as trees. |
| * @see #EXPANDABLE |
| * @see #EXPANDED |
| * @see AccessibleRole#TREE |
| */ |
| public static final AccessibleState COLLAPSED |
| = new AccessibleState("collapsed"); |
| |
| /** |
| * Indicates this object is expanded. This is usually paired with the |
| * EXPANDABLE state and is used on objects that provide progressive |
| * disclosure such as trees. |
| * @see #EXPANDABLE |
| * @see #COLLAPSED |
| * @see AccessibleRole#TREE |
| */ |
| public static final AccessibleState EXPANDED |
| = new AccessibleState("expanded"); |
| |
| /** |
| * Indicates this object is enabled. The absence of this state from an |
| * object's state set indicates this object is not enabled. An object |
| * that is not enabled cannot be manipulated by the user. In a graphical |
| * display, it is usually grayed out. |
| */ |
| public static final AccessibleState ENABLED |
| = new AccessibleState("enabled"); |
| |
| /** |
| * Indicates this object can accept keyboard focus, which means all |
| * events resulting from typing on the keyboard will normally be |
| * passed to it when it has focus. |
| * @see #FOCUSED |
| */ |
| public static final AccessibleState FOCUSABLE |
| = new AccessibleState("focusable"); |
| |
| /** |
| * Indicates this object currently has the keyboard focus. |
| * @see #FOCUSABLE |
| */ |
| public static final AccessibleState FOCUSED |
| = new AccessibleState("focused"); |
| |
| /** |
| * Indicates this object is minimized and is represented only by an |
| * icon. This is usually only associated with frames and internal |
| * frames. |
| * @see AccessibleRole#FRAME |
| * @see AccessibleRole#INTERNAL_FRAME |
| */ |
| public static final AccessibleState ICONIFIED |
| = new AccessibleState("iconified"); |
| |
| /** |
| * Indicates something must be done with this object before the |
| * user can interact with an object in a different window. This |
| * is usually associated only with dialogs. |
| * @see AccessibleRole#DIALOG |
| */ |
| public static final AccessibleState MODAL |
| = new AccessibleState("modal"); |
| |
| /** |
| * Indicates this object paints every pixel within its |
| * rectangular region. A non-opaque component paints only some of |
| * its pixels, allowing the pixels underneath it to "show through". |
| * A component that does not fully paint its pixels therefore |
| * provides a degree of transparency. |
| * @see Accessible#getAccessibleContext |
| * @see AccessibleContext#getAccessibleComponent |
| * @see AccessibleComponent#getBounds |
| */ |
| public static final AccessibleState OPAQUE |
| = new AccessibleState("opaque"); |
| |
| /** |
| * Indicates the size of this object is not fixed. |
| * @see Accessible#getAccessibleContext |
| * @see AccessibleContext#getAccessibleComponent |
| * @see AccessibleComponent#getSize |
| * @see AccessibleComponent#setSize |
| */ |
| public static final AccessibleState RESIZABLE |
| = new AccessibleState("resizable"); |
| |
| |
| /** |
| * Indicates this object allows more than one of its children to |
| * be selected at the same time. |
| * @see Accessible#getAccessibleContext |
| * @see AccessibleContext#getAccessibleSelection |
| * @see AccessibleSelection |
| */ |
| public static final AccessibleState MULTISELECTABLE |
| = new AccessibleState("multiselectable"); |
| |
| /** |
| * Indicates this object is the child of an object that allows its |
| * children to be selected, and that this child is one of those |
| * children that can be selected. |
| * @see #SELECTED |
| * @see Accessible#getAccessibleContext |
| * @see AccessibleContext#getAccessibleSelection |
| * @see AccessibleSelection |
| */ |
| public static final AccessibleState SELECTABLE |
| = new AccessibleState("selectable"); |
| |
| /** |
| * Indicates this object is the child of an object that allows its |
| * children to be selected, and that this child is one of those |
| * children that has been selected. |
| * @see #SELECTABLE |
| * @see Accessible#getAccessibleContext |
| * @see AccessibleContext#getAccessibleSelection |
| * @see AccessibleSelection |
| */ |
| public static final AccessibleState SELECTED |
| = new AccessibleState("selected"); |
| |
| /** |
| * Indicates this object, the object's parent, the object's parent's |
| * parent, and so on, are all visible. Note that this does not |
| * necessarily mean the object is painted on the screen. It might |
| * be occluded by some other showing object. |
| * @see #VISIBLE |
| */ |
| public static final AccessibleState SHOWING |
| = new AccessibleState("showing"); |
| |
| /** |
| * Indicates this object is visible. Note: this means that the |
| * object intends to be visible; however, it may not in fact be |
| * showing on the screen because one of the objects that this object |
| * is contained by is not visible. |
| * @see #SHOWING |
| */ |
| public static final AccessibleState VISIBLE |
| = new AccessibleState("visible"); |
| |
| /** |
| * Indicates the orientation of this object is vertical. This is |
| * usually associated with objects such as scrollbars, sliders, and |
| * progress bars. |
| * @see #VERTICAL |
| * @see AccessibleRole#SCROLL_BAR |
| * @see AccessibleRole#SLIDER |
| * @see AccessibleRole#PROGRESS_BAR |
| */ |
| public static final AccessibleState VERTICAL |
| = new AccessibleState("vertical"); |
| |
| /** |
| * Indicates the orientation of this object is horizontal. This is |
| * usually associated with objects such as scrollbars, sliders, and |
| * progress bars. |
| * @see #HORIZONTAL |
| * @see AccessibleRole#SCROLL_BAR |
| * @see AccessibleRole#SLIDER |
| * @see AccessibleRole#PROGRESS_BAR |
| */ |
| public static final AccessibleState HORIZONTAL |
| = new AccessibleState("horizontal"); |
| |
| /** |
| * Indicates this (text) object can contain only a single line of text |
| */ |
| public static final AccessibleState SINGLE_LINE |
| = new AccessibleState("singleline"); |
| |
| /** |
| * Indicates this (text) object can contain multiple lines of text |
| */ |
| public static final AccessibleState MULTI_LINE |
| = new AccessibleState("multiline"); |
| |
| /** |
| * Indicates this object is transient. An assistive technology should |
| * not add a PropertyChange listener to an object with transient state, |
| * as that object will never generate any events. Transient objects |
| * are typically created to answer Java Accessibility method queries, |
| * but otherwise do not remain linked to the underlying object (for |
| * example, those objects underneath lists, tables, and trees in Swing, |
| * where only one actual UI Component does shared rendering duty for |
| * all of the data objects underneath the actual list/table/tree elements). |
| * |
| * @since 1.5 |
| * |
| */ |
| public static final AccessibleState TRANSIENT |
| = new AccessibleState("transient"); |
| |
| /** |
| * Indicates this object is responsible for managing its |
| * subcomponents. This is typically used for trees and tables |
| * that have a large number of subcomponents and where the |
| * objects are created only when needed and otherwise remain virtual. |
| * The application should not manage the subcomponents directly. |
| * |
| * @since 1.5 |
| */ |
| public static final AccessibleState MANAGES_DESCENDANTS |
| = new AccessibleState ("managesDescendants"); |
| |
| /** |
| * Indicates that the object state is indeterminate. An example |
| * is selected text that is partially bold and partially not |
| * bold. In this case the attributes associated with the selected |
| * text are indeterminate. |
| * |
| * @since 1.5 |
| */ |
| public static final AccessibleState INDETERMINATE |
| = new AccessibleState ("indeterminate"); |
| |
| /** |
| * A state indicating that text is truncated by a bounding rectangle |
| * and that some of the text is not displayed on the screen. An example |
| * is text in a spreadsheet cell that is truncated by the bounds of |
| * the cell. |
| * |
| * @since 1.5 |
| */ |
| static public final AccessibleState TRUNCATED |
| = new AccessibleState("truncated"); |
| |
| /** |
| * Creates a new AccessibleState using the given locale independent key. |
| * This should not be a public method. Instead, it is used to create |
| * the constants in this file to make it a strongly typed enumeration. |
| * Subclasses of this class should enforce similar policy. |
| * <p> |
| * The key String should be a locale independent key for the state. |
| * It is not intended to be used as the actual String to display |
| * to the user. To get the localized string, use toDisplayString. |
| * |
| * @param key the locale independent name of the state. |
| * @see AccessibleBundle#toDisplayString |
| */ |
| protected AccessibleState(String key) { |
| this.key = key; |
| } |
| } |
