/* * Copyright (c) 1998, 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. */ /** * Defines a contract between user-interface components and an assistive * technology that provides access to those components. If a Java application * fully supports the Java Accessibility API, then it should be compatible with, * and friendly toward, assistive technologies such as screen readers, screen * magnifiers, etc. With a Java application that fully supports the Java * Accessibility API, no screen reader off screen model would be necessary * because the API provides all of the information normally contained in an off * screen model. *

* The Java Accessibility API package consists of 8 Java programming language * interfaces, and 6 Java programming language classes. These are described * below. * *

Interface * Accessible

* Interface Accessible is the main interface of * the Java Accessibility API. All components that support the Java * Accessibility API must implement this interface. It contains a single method, * {@code getAccessibleContext}, that returns an instance of the class * AccessibleContext. Sun thinks that * implementing this interface is the absolute minimum requirement of every * object that is part of the user interface of a Java application, if that * program is to be compatible with assistive technologies. * *

Class * AccessibleContext

* AccessibleContext represents the minimum * information all accessible objects return and is obtained by calling the * {@code getAccessibleContext} method on an object that implements the * Accessible interface. This information includes the * accessible name, description, role, and * state of the object, as well as information * about the parent and children of the object.  In addition, * JavaBeans property change support is also included to allow assistive * technologies learn when the values of the accessible properties change. * AccessibleContext also contains methods for obtaining more specific * accessibility information about a component. If the component supports it, * these methods will return an object that implements one or more of the * following interfaces: * * *

Class * AccessibleRole

* This class encapsulates the Accessible object's role in the user interface * and is obtained by calling the {@code getAccessibleRole} method on an * AccessibleContext. Accessible roles include * "Check box", "Menu Item", "Panel", etc. These roles are identified by the * constants in this class such as {@code AccessibleRole.CHECK_BOX, * AccessibleRole.MENU_ITEM,} and {@code AccessibleRole.PANEL}. 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. Although this class * pre-defines a large list of standard roles, it is extensible so additional * programmer-defined roles can be added in the future without needing to modify * the base class. * *

Class * AccessibleState

* This class encapsulates a particular state of the Accessible object. * Accessible states include things like "Armed", "Busy", "Checked", "Focused", * etc. These roles are identified by the constants in this class such as * {@code AccessibleState.ARMED, AccessibleState.BUSY, AccessibleState.CHECKED,} * and {@code AccessibleState.FOCUSED}. The sum of all the states of an * Accessible object is called the * AccessibleStateSet, and can be obtained by * calling the {@code getAccessibleStateSet} method on an * AccessibleContext. *

* 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. Although * this class pre-defines a large list of standard roles, it is extensible so * additional, programmer-defined roles can be added in the future without * needing to modify the base class. * *

Class * AccessibleStateSet

* This class encapsulates a collection of states of the Accessible object and * is obtained by calling the {@code getAccessibleStateSet} method on an * AccessibleContext. Since an object might * have multiple states (e.g. it might be both "Checked" and "Focused"), this * class is needed to encapsulate a collection of these states. Methods in the * class provide for retrieving the individual * AccessibleStates on the state set. * *

Class * AccessibleBundle

* This class is used to maintain a strongly typed enumeration. It is the super * class of both the AccessibleRole and * AccessibleState classes. Programmers normally * do not interact with this class directly, but will instead use the * AccessibleRole and * AccessibleState classes. * *

Interface * AccessibleAction

* The AccessibleAction interface should be * supported by any object that can perform one or more actions. This interface * provides the standard mechanism for an assistive technology to determine what * those actions are as well as tell the object to perform those actions. Any * object that can be manipulated should support this interface. *

* Applications can determine if an object supports the AccessibleAction * interface by first obtaining its * AccessibleContext (see * Accessible) and then calling the * {@code getAccessibleAction} method of * AccessibleContext. If the return value is * not {@code null}, the object supports this interface. * *

* Interface AccessibleComponent

* The AccessibleComponent interface * should be supported by any object that is rendered on the screen. This * interface provides the standard mechanism for an assistive technology to * determine and set the graphical representation of an object.

Applications * can determine if an object supports the AccessibleComponent interface by * first obtaining its AccessibleContext (see * Accessible) and then calling the * {@code getAccessibleComponent} method of * AccessibleContext. If the return value is * not {@code null}, the object supports this interface. * *

* Interface AccessibleSelection

* The AccessibleSelection interface * provides the standard mechanism for an assistive technology to determine what * the current selected children are, as well as modify the selection set. Any * object that has children that can be selected should support this the * AccessibleSelection interface. *

* Applications can determine if an object supports the AccessibleSelection * interface by first obtaining its * AccessibleContext (see * Accessible) and then calling the * {@code getAccessibleSelection} method of * AccessibleContext. If the return value is * not {@code null}, the object supports this interface. * *

Interface * AccessibleText

* Interface AccessibleText is the contract * for making rich, editable text Accessible. Not all text displayed on the * screen is rich and editable (e.g. text contained in buttons, labels, menus, * etc., which users aren't expected to manipulate). However, objects containing * editable text must implement interface AccessibleText if they are to * interoperate with assistive technologies. *

* This interface provides support for going between pixel coordinates and the * text at a given pixel coordinate, for retrieving the letter, word, and * sentence at, before, or after a given position in the text. This interface * provides support for retrieving the attributes of the character at a given * position in the text (font, font size, style, etc.), as well as getting the * selected text (if any), the length of the text, and the location of the text * caret. *

* Applications can determine if an object supports the AccessibleText interface * by first obtaining its AccessibleContext * (see Accessible) and then calling the * {@code getAccessibleText} method of * AccessibleContext. If the return value is * not {@code null}, the object supports this interface. * *

* Interface AccessibleHypertext

* The AccessibleHypertext interface * should be supported by any object that presents hypertext information on the * display. This interface provides the standard mechanism for an assistive * technology to access that text via its content, attributes, and spatial * location. It also provides standard mechanisms for manipulating * hyperlinks. Applications can determine if * an object supports the AccessibleHypertext interface by first obtaining its * AccessibleContext (see * Accessible) and then calling the * AccessibleContext.getAccessibleText() method of * AccessibleContext. If the return value is a * class which extends AccessibleHypertext, then that object supports * AccessibleHypertext. * *

* Interface AccessibleHyperlink

* An object that is a hyperlink should support the * AccessibleHyperlink interface.  * An object that implements this interface will be returned by calling the * getLink method on an AccessibleHypertext * object. * *

Interface * AccessibleValue

* The AccessibleValue interface should be * supported by any object that supports a numerical value (e.g., a scroll bar). * This interface provides the standard mechanism for an assistive technology to * determine and set the numerical value as well as get the minimum and maximum * values. *

* Applications can determine if an object supports the AccessibleValue * interface by first obtaining its * AccessibleContext (see * Accessible) and then calling the * {@code getAccessibleValue} method of * AccessibleContext. If the return value is * not {@code null}, the object supports this interface. * * @since 1.2 */ package javax.accessibility;