| /* |
| * Copyright (c) 1997, 2017, 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; |
| |
| /** |
| * Class {@code AccessibleState} describes a component's particular state. The |
| * actual state of the component is defined as an {@code AccessibleStateSet}, |
| * which is a composed set of {@code AccessibleStates}. |
| * <p> |
| * The {@link #toDisplayString()} method allows you to obtain the localized |
| * string for a locale independent key from a predefined {@code 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 {@code EXPANDED} or {@code 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 |
| * {@code 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 |
| * {@code 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 {@code 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 {@code 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 |
| */ |
| public static final AccessibleState TRUNCATED |
| = new AccessibleState("truncated"); |
| |
| /** |
| * Creates a new {@code 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 {@code String} should be a locale independent key for the state. |
| * It is not intended to be used as the actual {@code String} to display to |
| * the user. To get the localized string, use {@link #toDisplayString()}. |
| * |
| * @param key the locale independent name of the state |
| * @see AccessibleBundle#toDisplayString |
| */ |
| protected AccessibleState(String key) { |
| this.key = key; |
| } |
| } |
