/*
* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
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;
}
}