AccessibleContext.java

/*
 * Copyright (c) 1997, 2020, 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.awt.IllegalComponentStateException;
import java.beans.BeanProperty;
import java.beans.JavaBean;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Locale;

import sun.awt.AWTAccessor;
import sun.awt.AppContext;

/**
 * {@code AccessibleContext} represents the minimum information all accessible
 * objects return. This information includes the accessible name, description,
 * role, and state of the object, as well as information about its parent and
 * children. {@code AccessibleContext} also contains methods for obtaining more
 * specific accessibility information about a component. If the component
 * supports them, these methods will return an object that implements one or
 * more of the following interfaces:
 * <ul>
 *   <li>{@link AccessibleAction} - the object can perform one or more actions.
 *   This interface provides the standard mechanism for an assistive technology
 *   to determine what those actions are and tell the object to perform them.
 *   Any object that can be manipulated should support this interface.
 *   <li>{@link AccessibleComponent} - the object has a graphical
 *   representation. This interface provides the standard mechanism for an
 *   assistive technology to determine and set the graphical representation of
 *   the object. Any object that is rendered on the screen should support this
 *   interface.
 *   <li>{@link AccessibleSelection} - the object allows its children to be
 *   selected. This interface provides the standard mechanism for an assistive
 *   technology to determine the currently selected children of the object as
 *   well as modify its selection set. Any object that has children that can be
 *   selected should support this interface.
 *   <li>{@link AccessibleText} - the object presents editable textual
 *   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. Any object that contains editable text
 *   should support this interface.
 *   <li>{@link AccessibleValue} - the object supports a numerical value. This
 *   interface provides the standard mechanism for an assistive technology to
 *   determine and set the current value of the object, as well as obtain its
 *   minimum and maximum values. Any object that supports a numerical value
 *   should support this interface.
 * </ul>
 *
 * @author Peter Korn
 * @author Hans Muller
 * @author Willie Walker
 * @author Lynn Monsanto
 */
@JavaBean(description = "Minimal information that all accessible objects return")
public abstract class AccessibleContext {

    /**
     * Constructor for subclasses to call.
     */
    protected AccessibleContext() {}

    /**
     * The {@code AppContext} that should be used to dispatch events for this
     * {@code AccessibleContext}.
     */
    private volatile AppContext targetAppContext;

    static {
        AWTAccessor.setAccessibleContextAccessor(new AWTAccessor.AccessibleContextAccessor() {
            @Override
            public void setAppContext(AccessibleContext accessibleContext, AppContext appContext) {
                accessibleContext.targetAppContext = appContext;
            }

            @Override
            public AppContext getAppContext(AccessibleContext accessibleContext) {
                return accessibleContext.targetAppContext;
            }

            @Override
            public Object getNativeAXResource(AccessibleContext accessibleContext) {
                return accessibleContext.nativeAXResource;
            }

            @Override
            public void setNativeAXResource(AccessibleContext accessibleContext, Object value) {
                accessibleContext.nativeAXResource = value;
            }
        });
    }

    /**
     * Constant used to determine when the {@link #accessibleName} property has
     * changed. The old value in the {@code PropertyChangeEvent} will be the old
     * {@code accessibleName} and the new value will be the new
     * {@code accessibleName}.
     *
     * @see #getAccessibleName
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_NAME_PROPERTY = "AccessibleName";

    /**
     * Constant used to determine when the {@link #accessibleDescription}
     * property has changed. The old value in the {@code PropertyChangeEvent}
     * will be the old {@code accessibleDescription} and the new value will be
     * the new {@code accessibleDescription}.
     *
     * @see #getAccessibleDescription
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_DESCRIPTION_PROPERTY = "AccessibleDescription";

    /**
     * Constant used to determine when the {@code accessibleStateSet} property
     * has changed. The old value will be the old {@code AccessibleState} and
     * the new value will be the new {@code AccessibleState} in the
     * {@code accessibleStateSet}. For example, if a component that supports the
     * vertical and horizontal states changes its orientation from vertical to
     * horizontal, the old value will be {@code AccessibleState.VERTICAL} and
     * the new value will be {@code AccessibleState.HORIZONTAL}. Please note
     * that either value can also be {@code null}. For example, when a component
     * changes from being enabled to disabled, the old value will be
     * {@code AccessibleState.ENABLED} and the new value will be {@code null}.
     *
     * @see #getAccessibleStateSet
     * @see AccessibleState
     * @see AccessibleStateSet
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_STATE_PROPERTY = "AccessibleState";

    /**
     * Constant used to determine when the {@code accessibleValue} property has
     * changed. The old value in the {@code PropertyChangeEvent} will be a
     * {@code Number} representing the old value and the new value will be a
     * {@code Number} representing the new value.
     *
     * @see #getAccessibleValue
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_VALUE_PROPERTY = "AccessibleValue";

    /**
     * Constant used to determine when the {@code accessibleSelection} has
     * changed. The old and new values in the {@code PropertyChangeEvent} are
     * currently reserved for future use.
     *
     * @see #getAccessibleSelection
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_SELECTION_PROPERTY = "AccessibleSelection";

    /**
     * Constant used to determine when the {@code accessibleText} caret has
     * changed. The old value in the {@code PropertyChangeEvent} will be an
     * integer representing the old caret position, and the new value will be an
     * integer representing the new/current caret position.
     *
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_CARET_PROPERTY = "AccessibleCaret";

    /**
     * Constant used to determine when the visual appearance of the object has
     * changed. The old and new values in the {@code PropertyChangeEvent} are
     * currently reserved for future use.
     *
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_VISIBLE_DATA_PROPERTY = "AccessibleVisibleData";

    /**
     * Constant used to determine when {@code Accessible} children are
     * added/removed from the object. If an {@code Accessible} child is being
     * added, the old value will be {@code null} and the new value will be the
     * {@code Accessible} child. If an {@code Accessible} child is being
     * removed, the old value will be the {@code Accessible} child, and the new
     * value will be {@code null}.
     *
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_CHILD_PROPERTY = "AccessibleChild";

    /**
     * Constant used to determine when the active descendant of a component has
     * changed. The active descendant is used for objects such as list, tree,
     * and table, which may have transient children. When the active descendant
     * has changed, the old value of the property change event will be the
     * {@code Accessible} representing the previous active child, and the new
     * value will be the {@code Accessible} representing the current active
     * child.
     *
     * @see #addPropertyChangeListener
     */
    public static final String ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY = "AccessibleActiveDescendant";

    /**
     * Constant used to indicate that the table caption has changed. The old
     * value in the {@code PropertyChangeEvent} will be an {@code Accessible}
     * representing the previous table caption and the new value will be an
     * {@code Accessible} representing the new table caption.
     *
     * @see Accessible
     * @see AccessibleTable
     */
    public static final String ACCESSIBLE_TABLE_CAPTION_CHANGED =
        "accessibleTableCaptionChanged";

    /**
     * Constant used to indicate that the table summary has changed. The old
     * value in the {@code PropertyChangeEvent} will be an {@code Accessible}
     * representing the previous table summary and the new value will be an
     * {@code Accessible} representing the new table summary.
     *
     * @see Accessible
     * @see AccessibleTable
     */
    public static final String ACCESSIBLE_TABLE_SUMMARY_CHANGED =
        "accessibleTableSummaryChanged";

    /**
     * Constant used to indicate that table data has changed. The old value in
     * the {@code PropertyChangeEvent} will be {@code null} and the new value
     * will be an {@code AccessibleTableModelChange} representing the table
     * change.
     *
     * @see AccessibleTable
     * @see AccessibleTableModelChange
     */
    public static final String ACCESSIBLE_TABLE_MODEL_CHANGED =
        "accessibleTableModelChanged";

    /**
     * Constant used to indicate that the row header has changed. The old value
     * in the {@code PropertyChangeEvent} will be {@code null} and the new value
     * will be an {@code AccessibleTableModelChange} representing the header
     * change.
     *
     * @see AccessibleTable
     * @see AccessibleTableModelChange
     */
    public static final String ACCESSIBLE_TABLE_ROW_HEADER_CHANGED =
        "accessibleTableRowHeaderChanged";

    /**
     * Constant used to indicate that the row description has changed. The old
     * value in the {@code PropertyChangeEvent} will be {@code null} and the new
     * value will be an {@code Integer} representing the row index.
     *
     * @see AccessibleTable
     */
    public static final String ACCESSIBLE_TABLE_ROW_DESCRIPTION_CHANGED =
        "accessibleTableRowDescriptionChanged";

    /**
     * Constant used to indicate that the column header has changed. The old
     * value in the {@code PropertyChangeEvent} will be {@code null} and the new
     * value will be an {@code AccessibleTableModelChange} representing the
     * header change.
     *
     * @see AccessibleTable
     * @see AccessibleTableModelChange
     */
    public static final String ACCESSIBLE_TABLE_COLUMN_HEADER_CHANGED =
        "accessibleTableColumnHeaderChanged";

    /**
     * Constant used to indicate that the column description has changed. The
     * old value in the {@code PropertyChangeEvent} will be {@code null} and the
     * new value will be an {@code Integer} representing the column index.
     *
     * @see AccessibleTable
     */
    public static final String ACCESSIBLE_TABLE_COLUMN_DESCRIPTION_CHANGED =
        "accessibleTableColumnDescriptionChanged";

    /**
     * Constant used to indicate that the supported set of actions has changed.
     * The old value in the {@code PropertyChangeEvent} will be an
     * {@code Integer} representing the old number of actions supported and the
     * new value will be an {@code Integer} representing the new number of
     * actions supported.
     *
     * @see AccessibleAction
     */
    public static final String ACCESSIBLE_ACTION_PROPERTY =
        "accessibleActionProperty";

    /**
     * Constant used to indicate that a hypertext element has received focus.
     * The old value in the {@code PropertyChangeEvent} will be an
     * {@code Integer} representing the start index in the document of the
     * previous element that had focus and the new value will be an
     * {@code Integer} representing the start index in the document of the
     * current element that has focus. A value of -1 indicates that an element
     * does not or did not have focus.
     *
     * @see AccessibleHyperlink
     */
    public static final String ACCESSIBLE_HYPERTEXT_OFFSET =
        "AccessibleHypertextOffset";

    /**
     * {@code PropertyChangeEvent} which indicates that text has changed.
     * <br>
     * For text insertion, the {@code oldValue} is {@code null} and the
     * {@code newValue} is an {@code AccessibleTextSequence} specifying the text
     * that was inserted.
     * <br>
     * For text deletion, the {@code oldValue} is an
     * {@code AccessibleTextSequence} specifying the text that was deleted and
     * the {@code newValue} is {@code null}.
     * <br>
     * For text replacement, the {@code oldValue} is an
     * {@code AccessibleTextSequence} specifying the old text and the
     * {@code newValue} is an {@code AccessibleTextSequence} specifying the new
     * text.
     *
     * @see #getAccessibleText
     * @see #addPropertyChangeListener
     * @see AccessibleTextSequence
     */
    public static final String ACCESSIBLE_TEXT_PROPERTY
        = "AccessibleText";

    /**
     * {@code PropertyChangeEvent} which indicates that a significant change has
     * occurred to the children of a component like a tree or text. This change
     * notifies the event listener that it needs to reacquire the state of the
     * subcomponents. The {@code oldValue} is {@code null} and the
     * {@code newValue} is the component whose children have become invalid.
     *
     * @see #getAccessibleText
     * @see #addPropertyChangeListener
     * @see AccessibleTextSequence
     * @since 1.5
     */
    public static final String ACCESSIBLE_INVALIDATE_CHILDREN =
        "accessibleInvalidateChildren";

    /**
     * {@code PropertyChangeEvent} which indicates that text attributes have
     * changed.
     * <br>
     * For attribute insertion, the {@code oldValue} is {@code null} and the
     * {@code newValue} is an {@code AccessibleAttributeSequence} specifying the
     * attributes that were inserted.
     * <br>
     * For attribute deletion, the {@code oldValue} is an
     * {@code AccessibleAttributeSequence} specifying the attributes that were
     * deleted and the {@code newValue} is {@code null}.
     * <br>
     * For attribute replacement, the {@code oldValue} is an
     * {@code AccessibleAttributeSequence} specifying the old attributes and the
     * {@code newValue} is an {@code AccessibleAttributeSequence} specifying the
     * new attributes.
     *
     * @see #getAccessibleText
     * @see #addPropertyChangeListener
     * @see AccessibleAttributeSequence
     * @since 1.5
     */
    public static final String ACCESSIBLE_TEXT_ATTRIBUTES_CHANGED =
        "accessibleTextAttributesChanged";

    /**
     * {@code PropertyChangeEvent} which indicates that a change has occurred in
     * a component's bounds. The {@code oldValue} is the old component bounds
     * and the {@code newValue} is the new component bounds.
     *
     * @see #addPropertyChangeListener
     * @since 1.5
     */
    public static final String ACCESSIBLE_COMPONENT_BOUNDS_CHANGED =
        "accessibleComponentBoundsChanged";

    /**
     * The accessible parent of this object.
     *
     * @see #getAccessibleParent
     * @see #setAccessibleParent
     */
    protected Accessible accessibleParent = null;

    /**
     * A localized String containing the name of the object.
     *
     * @see #getAccessibleName
     * @see #setAccessibleName
     */
    protected String accessibleName = null;

    /**
     * A localized String containing the description of the object.
     *
     * @see #getAccessibleDescription
     * @see #setAccessibleDescription
     */
    protected String accessibleDescription = null;

    /**
     * Used to handle the listener list for property change events.
     *
     * @see #addPropertyChangeListener
     * @see #removePropertyChangeListener
     * @see #firePropertyChange
     */
    private PropertyChangeSupport accessibleChangeSupport = null;

    /**
     * Used to represent the context's relation set.
     *
     * @see #getAccessibleRelationSet
     */
    private AccessibleRelationSet relationSet
        = new AccessibleRelationSet();

    private Object nativeAXResource;

    /**
     * Gets the {@code accessibleName} property of this object. The
     * {@code accessibleName} property of an object is a localized
     * {@code String} that designates the purpose of the object. For example,
     * the {@code accessibleName} property of a label or button might be the
     * text of the label or button itself. In the case of an object that doesn't
     * display its name, the {@code accessibleName} should still be set. For
     * example, in the case of a text field used to enter the name of a city,
     * the {@code accessibleName} for the {@code en_US} locale could be 'city.'
     *
     * @return the localized name of the object; {@code null} if this object
     *         does not have a name
     * @see #setAccessibleName
     */
    public String getAccessibleName() {
        return accessibleName;
    }

    /**
     * Sets the localized accessible name of this object. Changing the name will
     * cause a {@code PropertyChangeEvent} to be fired for the
     * {@code ACCESSIBLE_NAME_PROPERTY} property.
     *
     * @param  s the new localized name of the object
     * @see #getAccessibleName
     * @see #addPropertyChangeListener
     */
    @BeanProperty(preferred = true, description
            = "Sets the accessible name for the component.")
    public void setAccessibleName(String s) {
        String oldName = accessibleName;
        accessibleName = s;
        firePropertyChange(ACCESSIBLE_NAME_PROPERTY,oldName,accessibleName);
    }

    /**
     * Gets the {@code accessibleDescription} property of this object. The
     * {@code accessibleDescription} property of this object is a short
     * localized phrase describing the purpose of the object. For example, in
     * the case of a 'Cancel' button, the {@code accessibleDescription} could be
     * 'Ignore changes and close dialog box.'
     *
     * @return the localized description of the object; {@code null} if this
     *         object does not have a description
     * @see #setAccessibleDescription
     */
    public String getAccessibleDescription() {
        return accessibleDescription;
    }

    /**
     * Sets the accessible description of this object. Changing the name will
     * cause a {@code PropertyChangeEvent} to be fired for the
     * {@code ACCESSIBLE_DESCRIPTION_PROPERTY} property.
     *
     * @param  s the new localized description of the object
     * @see #setAccessibleName
     * @see #addPropertyChangeListener
     */
    @BeanProperty(preferred = true, description
            = "Sets the accessible description for the component.")
    public void setAccessibleDescription(String s) {
        String oldDescription = accessibleDescription;
        accessibleDescription = s;
        firePropertyChange(ACCESSIBLE_DESCRIPTION_PROPERTY,
                           oldDescription,accessibleDescription);
    }

    /**
     * Gets the role of this object. The role of the object is the generic
     * purpose or use of the class of this object. For example, the role of a
     * push button is {@code AccessibleRole.PUSH_BUTTON}. The roles in
     * {@code AccessibleRole} are provided so component developers can pick from
     * a set of predefined roles. This enables assistive technologies to provide
     * a consistent interface to various tweaked subclasses of components (e.g.,
     * use {@code AccessibleRole.PUSH_BUTTON} for all components that act like a
     * push button) as well as distinguish between subclasses that behave
     * differently (e.g., {@code AccessibleRole.CHECK_BOX} for check boxes and
     * {@code AccessibleRole.RADIO_BUTTON} for radio buttons).
     * <p>
     * Note that the {@code AccessibleRole} class is also extensible, so custom
     * component developers can define their own {@code AccessibleRole}'s if the
     * set of predefined roles is inadequate.
     *
     * @return an instance of {@code AccessibleRole} describing the role of the
     *         object
     * @see AccessibleRole
     */
    public abstract AccessibleRole getAccessibleRole();

    /**
     * Gets the state set of this object. The {@code AccessibleStateSet} of an
     * object is composed of a set of unique {@code AccessibleStates}. A change
     * in the {@code AccessibleStateSet} of an object will cause a
     * {@code PropertyChangeEvent} to be fired for the
     * {@code ACCESSIBLE_STATE_PROPERTY} property.
     *
     * @return an instance of {@code AccessibleStateSet} containing the current
     *         state set of the object
     * @see AccessibleStateSet
     * @see AccessibleState
     * @see #addPropertyChangeListener
     */
    public abstract AccessibleStateSet getAccessibleStateSet();

    /**
     * Gets the {@code Accessible} parent of this object.
     *
     * @return the {@code Accessible} parent of this object; {@code null} if
     *         this object does not have an {@code Accessible} parent
     */
    public Accessible getAccessibleParent() {
        return accessibleParent;
    }

    /**
     * Sets the {@code Accessible} parent of this object. This is meant to be
     * used only in the situations where the actual component's parent should
     * not be treated as the component's accessible parent and is a method that
     * should only be called by the parent of the accessible child.
     *
     * @param  a - {@code Accessible} to be set as the parent
     */
    public void setAccessibleParent(Accessible a) {
        accessibleParent = a;
    }

    /**
     * Gets the 0-based index of this object in its accessible parent.
     *
     * @return the 0-based index of this object in its parent; -1 if this object
     *         does not have an accessible parent.
     * @see #getAccessibleParent
     * @see #getAccessibleChildrenCount
     * @see #getAccessibleChild
     */
    public abstract int getAccessibleIndexInParent();

    /**
     * Returns the number of accessible children of the object.
     *
     * @return the number of accessible children of the object.
     */
    public abstract int getAccessibleChildrenCount();

    /**
     * Returns the specified {@code Accessible} child of the object. The
     * {@code Accessible} children of an {@code Accessible} object are
     * zero-based, so the first child of an {@code Accessible} child is at index
     * 0, the second child is at index 1, and so on.
     *
     * @param  i zero-based index of child
     * @return the {@code Accessible} child of the object
     * @see #getAccessibleChildrenCount
     */
    public abstract Accessible getAccessibleChild(int i);

    /**
     * Gets the locale of the component. If the component does not have a
     * locale, then the locale of its parent is returned.
     *
     * @return this component's locale. If this component does not have a
     *         locale, the locale of its parent is returned.
     * @throws IllegalComponentStateException If the component does not have its
     *         own locale and has not yet been added to a containment hierarchy
     *         such that the locale can be determined from the containing
     *         parent
     */
    public abstract Locale getLocale() throws IllegalComponentStateException;

    /**
     * Adds a {@code PropertyChangeListener} to the listener list. The listener
     * is registered for all {@code Accessible} properties and will be called
     * when those properties change.
     *
     * @param  listener The PropertyChangeListener to be added
     * @see #ACCESSIBLE_NAME_PROPERTY
     * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
     * @see #ACCESSIBLE_STATE_PROPERTY
     * @see #ACCESSIBLE_VALUE_PROPERTY
     * @see #ACCESSIBLE_SELECTION_PROPERTY
     * @see #ACCESSIBLE_TEXT_PROPERTY
     * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
     */
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        if (accessibleChangeSupport == null) {
            accessibleChangeSupport = new PropertyChangeSupport(this);
        }
        accessibleChangeSupport.addPropertyChangeListener(listener);
    }

    /**
     * Removes a {@code PropertyChangeListener} from the listener list. This
     * removes a {@code PropertyChangeListener} that was registered for all
     * properties.
     *
     * @param  listener The PropertyChangeListener to be removed
     */
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        if (accessibleChangeSupport != null) {
            accessibleChangeSupport.removePropertyChangeListener(listener);
        }
    }

    /**
     * Gets the {@code AccessibleAction} associated with this object that
     * supports one or more actions.
     *
     * @return {@code AccessibleAction} if supported by object; else return
     *         {@code null}
     * @see AccessibleAction
     */
    public AccessibleAction getAccessibleAction() {
        return null;
    }

    /**
     * Gets the {@code AccessibleComponent} associated with this object that has
     * a graphical representation.
     *
     * @return {@code AccessibleComponent} if supported by object; else return
     *         {@code null}
     * @see AccessibleComponent
     */
    public AccessibleComponent getAccessibleComponent() {
        return null;
    }

    /**
     * Gets the {@code AccessibleSelection} associated with this object which
     * allows its {@code Accessible} children to be selected.
     *
     * @return {@code AccessibleSelection} if supported by object; else return
     *         {@code null}
     * @see AccessibleSelection
     */
    public AccessibleSelection getAccessibleSelection() {
        return null;
    }

    /**
     * Gets the {@code AccessibleText} associated with this object presenting
     * text on the display.
     *
     * @return {@code AccessibleText} if supported by object; else return
     *         {@code null}
     * @see AccessibleText
     */
    public AccessibleText getAccessibleText() {
        return null;
    }

    /**
     * Gets the {@code AccessibleEditableText} associated with this object
     * presenting editable text on the display.
     *
     * @return {@code AccessibleEditableText} if supported by object; else
     *         return {@code null}
     * @see AccessibleEditableText
     * @since 1.4
     */
    public AccessibleEditableText getAccessibleEditableText() {
        return null;
    }

    /**
     * Gets the {@code AccessibleValue} associated with this object that
     * supports a {@code Numerical} value.
     *
     * @return {@code AccessibleValue} if supported by object; else return
     *         {@code null}
     * @see AccessibleValue
     */
    public AccessibleValue getAccessibleValue() {
        return null;
    }

    /**
     * Gets the {@code AccessibleIcons} associated with an object that has one
     * or more associated icons.
     *
     * @return an array of {@code AccessibleIcon} if supported by object;
     *         otherwise return {@code null}
     * @see AccessibleIcon
     * @since 1.3
     */
    public AccessibleIcon [] getAccessibleIcon() {
        return null;
    }

    /**
     * Gets the {@code AccessibleRelationSet} associated with an object.
     *
     * @return an {@code AccessibleRelationSet} if supported by object;
     *         otherwise return {@code null}
     * @see AccessibleRelationSet
     * @since 1.3
     */
    public AccessibleRelationSet getAccessibleRelationSet() {
        return relationSet;
    }

    /**
     * Gets the {@code AccessibleTable} associated with an object.
     *
     * @return an {@code AccessibleTable} if supported by object; otherwise return
     *         {@code null}
     * @see AccessibleTable
     * @since 1.3
     */
    public AccessibleTable getAccessibleTable() {
        return null;
    }

    /**
     * Support for reporting bound property changes. If {@code oldValue} and
     * {@code newValue} are not equal and the {@code PropertyChangeEvent}
     * listener list is not empty, then fire a {@code PropertyChange} event to
     * each listener. In general, this is for use by the {@code Accessible}
     * objects themselves and should not be called by an application program.
     *
     * @param  propertyName The programmatic name of the property that was
     *         changed
     * @param  oldValue The old value of the property
     * @param  newValue The new value of the property
     * @see PropertyChangeSupport
     * @see #addPropertyChangeListener
     * @see #removePropertyChangeListener
     * @see #ACCESSIBLE_NAME_PROPERTY
     * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
     * @see #ACCESSIBLE_STATE_PROPERTY
     * @see #ACCESSIBLE_VALUE_PROPERTY
     * @see #ACCESSIBLE_SELECTION_PROPERTY
     * @see #ACCESSIBLE_TEXT_PROPERTY
     * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
     */
    public void firePropertyChange(String propertyName,
                                   Object oldValue,
                                   Object newValue) {
        if (accessibleChangeSupport != null) {
            if (newValue instanceof PropertyChangeEvent) {
                PropertyChangeEvent pce = (PropertyChangeEvent)newValue;
                accessibleChangeSupport.firePropertyChange(pce);
            } else {
                accessibleChangeSupport.firePropertyChange(propertyName,
                                                           oldValue,
                                                           newValue);
            }
        }
    }
}