View Javadoc
1   /*
2    * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package javax.accessibility;
27  
28  import java.util.Locale;
29  import java.beans.PropertyChangeListener;
30  import java.beans.PropertyChangeSupport;
31  import java.beans.PropertyChangeEvent;
32  import java.awt.IllegalComponentStateException;
33  
34  /**
35   * AccessibleContext represents the minimum information all accessible objects
36   * return.  This information includes the accessible name, description, role,
37   * and state of the object, as well as information about its parent and
38   * children.  AccessibleContext also contains methods for
39   * obtaining more specific accessibility information about a component.
40   * If the component supports them, these methods will return an object that
41   * implements one or more of the following interfaces:
42   * <P><ul>
43   * <li>{@link AccessibleAction} - the object can perform one or more actions.
44   * This interface provides the standard mechanism for an assistive
45   * technology to determine what those actions are and tell the object
46   * to perform them.  Any object that can be manipulated should
47   * support this interface.
48   * <li>{@link AccessibleComponent} - the object has a graphical representation.
49   * This interface provides the standard mechanism for an assistive
50   * technology to determine and set the graphical representation of the
51   * object.  Any object that is rendered on the screen should support
52   * this interface.
53   * <li>{@link  AccessibleSelection} - the object allows its children to be
54   * selected.  This interface provides the standard mechanism for an
55   * assistive technology to determine the currently selected children of the object
56   * as well as modify its selection set.  Any object that has children
57   * that can be selected should support this interface.
58   * <li>{@link AccessibleText} - the object presents editable textual information
59   * on the display.  This interface provides the standard mechanism for
60   * an assistive technology to access that text via its content, attributes,
61   * and spatial location.  Any object that contains editable text should
62   * support this interface.
63   * <li>{@link AccessibleValue} - the object supports a numerical value.  This
64   * interface provides the standard mechanism for an assistive technology
65   * to determine and set the current value of the object, as well as obtain its
66   * minimum and maximum values.  Any object that supports a numerical value
67   * should support this interface.</ul>
68   *
69   *
70   * @beaninfo
71   *   attribute: isContainer false
72   * description: Minimal information that all accessible objects return
73   *
74  
75   * @author      Peter Korn
76   * @author      Hans Muller
77   * @author      Willie Walker
78   * @author      Lynn Monsanto
79   */
80  public abstract class AccessibleContext {
81  
82     /**
83      * Constant used to determine when the accessibleName property has
84      * changed.  The old value in the PropertyChangeEvent will be the old
85      * accessibleName and the new value will be the new accessibleName.
86      *
87      * @see #getAccessibleName
88      * @see #addPropertyChangeListener
89      */
90     public static final String ACCESSIBLE_NAME_PROPERTY = "AccessibleName";
91  
92     /**
93      * Constant used to determine when the accessibleDescription property has
94      * changed.  The old value in the PropertyChangeEvent will be the
95      * old accessibleDescription and the new value will be the new
96      * accessibleDescription.
97      *
98      * @see #getAccessibleDescription
99      * @see #addPropertyChangeListener
100     */
101    public static final String ACCESSIBLE_DESCRIPTION_PROPERTY = "AccessibleDescription";
102 
103    /**
104     * Constant used to determine when the accessibleStateSet property has
105     * changed.  The old value will be the old AccessibleState and the new
106     * value will be the new AccessibleState in the accessibleStateSet.
107     * For example, if a component that supports the vertical and horizontal
108     * states changes its orientation from vertical to horizontal, the old
109     * value will be AccessibleState.VERTICAL and the new value will be
110     * AccessibleState.HORIZONTAL.  Please note that either value can also
111     * be null.  For example, when a component changes from being enabled
112     * to disabled, the old value will be AccessibleState.ENABLED
113     * and the new value will be null.
114     *
115     * @see #getAccessibleStateSet
116     * @see AccessibleState
117     * @see AccessibleStateSet
118     * @see #addPropertyChangeListener
119     */
120    public static final String ACCESSIBLE_STATE_PROPERTY = "AccessibleState";
121 
122    /**
123     * Constant used to determine when the accessibleValue property has
124     * changed.  The old value in the PropertyChangeEvent will be a Number
125     * representing the old value and the new value will be a Number
126     * representing the new value
127     *
128     * @see #getAccessibleValue
129     * @see #addPropertyChangeListener
130     */
131    public static final String ACCESSIBLE_VALUE_PROPERTY = "AccessibleValue";
132 
133    /**
134     * Constant used to determine when the accessibleSelection has changed.
135     * The old and new values in the PropertyChangeEvent are currently
136     * reserved for future use.
137     *
138     * @see #getAccessibleSelection
139     * @see #addPropertyChangeListener
140     */
141    public static final String ACCESSIBLE_SELECTION_PROPERTY = "AccessibleSelection";
142 
143    /**
144     * Constant used to determine when the accessibleText caret has changed.
145     * The old value in the PropertyChangeEvent will be an
146     * integer representing the old caret position, and the new value will
147     * be an integer representing the new/current caret position.
148     *
149     * @see #addPropertyChangeListener
150     */
151    public static final String ACCESSIBLE_CARET_PROPERTY = "AccessibleCaret";
152 
153    /**
154     * Constant used to determine when the visual appearance of the object
155     * has changed.  The old and new values in the PropertyChangeEvent are
156     * currently reserved for future use.
157     *
158     * @see #addPropertyChangeListener
159     */
160    public static final String ACCESSIBLE_VISIBLE_DATA_PROPERTY = "AccessibleVisibleData";
161 
162    /**
163     * Constant used to determine when Accessible children are added/removed
164     * from the object.  If an Accessible child is being added, the old
165     * value will be null and the new value will be the Accessible child.  If an
166     * Accessible child is being removed, the old value will be the Accessible
167     * child, and the new value will be null.
168     *
169     * @see #addPropertyChangeListener
170     */
171    public static final String ACCESSIBLE_CHILD_PROPERTY = "AccessibleChild";
172 
173    /**
174     * Constant used to determine when the active descendant of a component
175     * has changed.  The active descendant is used for objects such as
176     * list, tree, and table, which may have transient children.  When the
177     * active descendant has changed, the old value of the property change
178     * event will be the Accessible representing the previous active child, and
179     * the new value will be the Accessible representing the current active
180     * child.
181     *
182     * @see #addPropertyChangeListener
183     */
184    public static final String ACCESSIBLE_ACTIVE_DESCENDANT_PROPERTY = "AccessibleActiveDescendant";
185 
186     /**
187      * Constant used to indicate that the table caption has changed
188      * The old value in the PropertyChangeEvent will be an Accessible
189      * representing the previous table caption and the new value will
190      * be an Accessible representing the new table caption.
191      * @see Accessible
192      * @see AccessibleTable
193      */
194     public static final String ACCESSIBLE_TABLE_CAPTION_CHANGED =
195         "accessibleTableCaptionChanged";
196 
197     /**
198      * Constant used to indicate that the table summary has changed
199      * The old value in the PropertyChangeEvent will be an Accessible
200      * representing the previous table summary and the new value will
201      * be an Accessible representing the new table summary.
202      * @see Accessible
203      * @see AccessibleTable
204      */
205     public static final String ACCESSIBLE_TABLE_SUMMARY_CHANGED =
206         "accessibleTableSummaryChanged";
207 
208     /**
209      * Constant used to indicate that table data has changed.
210      * The old value in the PropertyChangeEvent will be null and the
211      * new value will be an AccessibleTableModelChange representing
212      * the table change.
213      * @see AccessibleTable
214      * @see AccessibleTableModelChange
215      */
216     public static final String ACCESSIBLE_TABLE_MODEL_CHANGED =
217         "accessibleTableModelChanged";
218 
219     /**
220      * Constant used to indicate that the row header has changed
221      * The old value in the PropertyChangeEvent will be null and the
222      * new value will be an AccessibleTableModelChange representing
223      * the header change.
224      * @see AccessibleTable
225      * @see AccessibleTableModelChange
226      */
227     public static final String ACCESSIBLE_TABLE_ROW_HEADER_CHANGED =
228         "accessibleTableRowHeaderChanged";
229 
230     /**
231      * Constant used to indicate that the row description has changed
232      * The old value in the PropertyChangeEvent will be null and the
233      * new value will be an Integer representing the row index.
234      * @see AccessibleTable
235      */
236     public static final String ACCESSIBLE_TABLE_ROW_DESCRIPTION_CHANGED =
237         "accessibleTableRowDescriptionChanged";
238 
239     /**
240      * Constant used to indicate that the column header has changed
241      * The old value in the PropertyChangeEvent will be null and the
242      * new value will be an AccessibleTableModelChange representing
243      * the header change.
244      * @see AccessibleTable
245      * @see AccessibleTableModelChange
246      */
247     public static final String ACCESSIBLE_TABLE_COLUMN_HEADER_CHANGED =
248         "accessibleTableColumnHeaderChanged";
249 
250     /**
251      * Constant used to indicate that the column description has changed
252      * The old value in the PropertyChangeEvent will be null and the
253      * new value will be an Integer representing the column index.
254      * @see AccessibleTable
255      */
256     public static final String ACCESSIBLE_TABLE_COLUMN_DESCRIPTION_CHANGED =
257         "accessibleTableColumnDescriptionChanged";
258 
259     /**
260      * Constant used to indicate that the supported set of actions
261      * has changed.  The old value in the PropertyChangeEvent will
262      * be an Integer representing the old number of actions supported
263      * and the new value will be an Integer representing the new
264      * number of actions supported.
265      * @see AccessibleAction
266      */
267     public static final String ACCESSIBLE_ACTION_PROPERTY =
268         "accessibleActionProperty";
269 
270     /**
271      * Constant used to indicate that a hypertext element has received focus.
272      * The old value in the PropertyChangeEvent will be an Integer
273      * representing the start index in the document of the previous element
274      * that had focus and the new value will be an Integer representing
275      * the start index in the document of the current element that has
276      * focus.  A value of -1 indicates that an element does not or did
277      * not have focus.
278      * @see AccessibleHyperlink
279      */
280     public static final String ACCESSIBLE_HYPERTEXT_OFFSET =
281         "AccessibleHypertextOffset";
282 
283     /**
284      * PropertyChangeEvent which indicates that text has changed.
285      * <br>
286      * For text insertion, the oldValue is null and the newValue
287      * is an AccessibleTextSequence specifying the text that was
288      * inserted.
289      * <br>
290      * For text deletion, the oldValue is an AccessibleTextSequence
291      * specifying the text that was deleted and the newValue is null.
292      * <br>
293      * For text replacement, the oldValue is an AccessibleTextSequence
294      * specifying the old text and the newValue is an AccessibleTextSequence
295      * specifying the new text.
296      *
297      * @see #getAccessibleText
298      * @see #addPropertyChangeListener
299      * @see AccessibleTextSequence
300      */
301     public static final String ACCESSIBLE_TEXT_PROPERTY
302         = "AccessibleText";
303 
304     /**
305      * PropertyChangeEvent which indicates that a significant change
306      * has occurred to the children of a component like a tree or text.
307      * This change notifies the event listener that it needs to
308      * reacquire the state of the subcomponents. The oldValue is
309      * null and the newValue is the component whose children have
310      * become invalid.
311      *
312      * @see #getAccessibleText
313      * @see #addPropertyChangeListener
314      * @see AccessibleTextSequence
315      *
316      * @since 1.5
317      */
318     public static final String ACCESSIBLE_INVALIDATE_CHILDREN =
319         "accessibleInvalidateChildren";
320 
321      /**
322      * PropertyChangeEvent which indicates that text attributes have changed.
323      * <br>
324      * For attribute insertion, the oldValue is null and the newValue
325      * is an AccessibleAttributeSequence specifying the attributes that were
326      * inserted.
327      * <br>
328      * For attribute deletion, the oldValue is an AccessibleAttributeSequence
329      * specifying the attributes that were deleted and the newValue is null.
330      * <br>
331      * For attribute replacement, the oldValue is an AccessibleAttributeSequence
332      * specifying the old attributes and the newValue is an
333      * AccessibleAttributeSequence specifying the new attributes.
334      *
335      * @see #getAccessibleText
336      * @see #addPropertyChangeListener
337      * @see AccessibleAttributeSequence
338      *
339      * @since 1.5
340      */
341     public static final String ACCESSIBLE_TEXT_ATTRIBUTES_CHANGED =
342         "accessibleTextAttributesChanged";
343 
344    /**
345      * PropertyChangeEvent which indicates that a change has occurred
346      * in a component's bounds.
347      * The oldValue is the old component bounds and the newValue is
348      * the new component bounds.
349      *
350      * @see #addPropertyChangeListener
351      *
352      * @since 1.5
353      */
354     public static final String ACCESSIBLE_COMPONENT_BOUNDS_CHANGED =
355         "accessibleComponentBoundsChanged";
356 
357     /**
358      * The accessible parent of this object.
359      *
360      * @see #getAccessibleParent
361      * @see #setAccessibleParent
362      */
363     protected Accessible accessibleParent = null;
364 
365     /**
366      * A localized String containing the name of the object.
367      *
368      * @see #getAccessibleName
369      * @see #setAccessibleName
370      */
371     protected String accessibleName = null;
372 
373     /**
374      * A localized String containing the description of the object.
375      *
376      * @see #getAccessibleDescription
377      * @see #setAccessibleDescription
378      */
379     protected String accessibleDescription = null;
380 
381     /**
382      * Used to handle the listener list for property change events.
383      *
384      * @see #addPropertyChangeListener
385      * @see #removePropertyChangeListener
386      * @see #firePropertyChangeListener
387      */
388     private PropertyChangeSupport accessibleChangeSupport = null;
389 
390     /**
391      * Used to represent the context's relation set
392      * @see #getAccessibleRelationSet
393      */
394     private AccessibleRelationSet relationSet
395         = new AccessibleRelationSet();
396 
397     private Object nativeAXResource;
398 
399     /**
400      * Gets the accessibleName property of this object.  The accessibleName
401      * property of an object is a localized String that designates the purpose
402      * of the object.  For example, the accessibleName property of a label
403      * or button might be the text of the label or button itself.  In the
404      * case of an object that doesn't display its name, the accessibleName
405      * should still be set.  For example, in the case of a text field used
406      * to enter the name of a city, the accessibleName for the en_US locale
407      * could be 'city.'
408      *
409      * @return the localized name of the object; null if this
410      * object does not have a name
411      *
412      * @see #setAccessibleName
413      */
414     public String getAccessibleName() {
415         return accessibleName;
416     }
417 
418     /**
419      * Sets the localized accessible name of this object.  Changing the
420      * name will cause a PropertyChangeEvent to be fired for the
421      * ACCESSIBLE_NAME_PROPERTY property.
422      *
423      * @param s the new localized name of the object.
424      *
425      * @see #getAccessibleName
426      * @see #addPropertyChangeListener
427      *
428      * @beaninfo
429      *    preferred:   true
430      *    description: Sets the accessible name for the component.
431      */
432     public void setAccessibleName(String s) {
433         String oldName = accessibleName;
434         accessibleName = s;
435         firePropertyChange(ACCESSIBLE_NAME_PROPERTY,oldName,accessibleName);
436     }
437 
438     /**
439      * Gets the accessibleDescription property of this object.  The
440      * accessibleDescription property of this object is a short localized
441      * phrase describing the purpose of the object.  For example, in the
442      * case of a 'Cancel' button, the accessibleDescription could be
443      * 'Ignore changes and close dialog box.'
444      *
445      * @return the localized description of the object; null if
446      * this object does not have a description
447      *
448      * @see #setAccessibleDescription
449      */
450     public String getAccessibleDescription() {
451         return accessibleDescription;
452     }
453 
454     /**
455      * Sets the accessible description of this object.  Changing the
456      * name will cause a PropertyChangeEvent to be fired for the
457      * ACCESSIBLE_DESCRIPTION_PROPERTY property.
458      *
459      * @param s the new localized description of the object
460      *
461      * @see #setAccessibleName
462      * @see #addPropertyChangeListener
463      *
464      * @beaninfo
465      *    preferred:   true
466      *    description: Sets the accessible description for the component.
467      */
468     public void setAccessibleDescription(String s) {
469         String oldDescription = accessibleDescription;
470         accessibleDescription = s;
471         firePropertyChange(ACCESSIBLE_DESCRIPTION_PROPERTY,
472                            oldDescription,accessibleDescription);
473     }
474 
475     /**
476      * Gets the role of this object.  The role of the object is the generic
477      * purpose or use of the class of this object.  For example, the role
478      * of a push button is AccessibleRole.PUSH_BUTTON.  The roles in
479      * AccessibleRole are provided so component developers can pick from
480      * a set of predefined roles.  This enables assistive technologies to
481      * provide a consistent interface to various tweaked subclasses of
482      * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
483      * that act like a push button) as well as distinguish between subclasses
484      * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
485      * and AccessibleRole.RADIO_BUTTON for radio buttons).
486      * <p>Note that the AccessibleRole class is also extensible, so
487      * custom component developers can define their own AccessibleRole's
488      * if the set of predefined roles is inadequate.
489      *
490      * @return an instance of AccessibleRole describing the role of the object
491      * @see AccessibleRole
492      */
493     public abstract AccessibleRole getAccessibleRole();
494 
495     /**
496      * Gets the state set of this object.  The AccessibleStateSet of an object
497      * is composed of a set of unique AccessibleStates.  A change in the
498      * AccessibleStateSet of an object will cause a PropertyChangeEvent to
499      * be fired for the ACCESSIBLE_STATE_PROPERTY property.
500      *
501      * @return an instance of AccessibleStateSet containing the
502      * current state set of the object
503      * @see AccessibleStateSet
504      * @see AccessibleState
505      * @see #addPropertyChangeListener
506      */
507     public abstract AccessibleStateSet getAccessibleStateSet();
508 
509     /**
510      * Gets the Accessible parent of this object.
511      *
512      * @return the Accessible parent of this object; null if this
513      * object does not have an Accessible parent
514      */
515     public Accessible getAccessibleParent() {
516         return accessibleParent;
517     }
518 
519     /**
520      * Sets the Accessible parent of this object.  This is meant to be used
521      * only in the situations where the actual component's parent should
522      * not be treated as the component's accessible parent and is a method
523      * that should only be called by the parent of the accessible child.
524      *
525      * @param a - Accessible to be set as the parent
526      */
527     public void setAccessibleParent(Accessible a) {
528         accessibleParent = a;
529     }
530 
531     /**
532      * Gets the 0-based index of this object in its accessible parent.
533      *
534      * @return the 0-based index of this object in its parent; -1 if this
535      * object does not have an accessible parent.
536      *
537      * @see #getAccessibleParent
538      * @see #getAccessibleChildrenCount
539      * @see #getAccessibleChild
540      */
541     public abstract int getAccessibleIndexInParent();
542 
543     /**
544      * Returns the number of accessible children of the object.
545      *
546      * @return the number of accessible children of the object.
547      */
548     public abstract int getAccessibleChildrenCount();
549 
550     /**
551      * Returns the specified Accessible child of the object.  The Accessible
552      * children of an Accessible object are zero-based, so the first child
553      * of an Accessible child is at index 0, the second child is at index 1,
554      * and so on.
555      *
556      * @param i zero-based index of child
557      * @return the Accessible child of the object
558      * @see #getAccessibleChildrenCount
559      */
560     public abstract Accessible getAccessibleChild(int i);
561 
562     /**
563      * Gets the locale of the component. If the component does not have a
564      * locale, then the locale of its parent is returned.
565      *
566      * @return this component's locale.  If this component does not have
567      * a locale, the locale of its parent is returned.
568      *
569      * @exception IllegalComponentStateException
570      * If the Component does not have its own locale and has not yet been
571      * added to a containment hierarchy such that the locale can be
572      * determined from the containing parent.
573      */
574     public abstract Locale getLocale() throws IllegalComponentStateException;
575 
576     /**
577      * Adds a PropertyChangeListener to the listener list.
578      * The listener is registered for all Accessible properties and will
579      * be called when those properties change.
580      *
581      * @see #ACCESSIBLE_NAME_PROPERTY
582      * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
583      * @see #ACCESSIBLE_STATE_PROPERTY
584      * @see #ACCESSIBLE_VALUE_PROPERTY
585      * @see #ACCESSIBLE_SELECTION_PROPERTY
586      * @see #ACCESSIBLE_TEXT_PROPERTY
587      * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
588      *
589      * @param listener  The PropertyChangeListener to be added
590      */
591     public void addPropertyChangeListener(PropertyChangeListener listener) {
592         if (accessibleChangeSupport == null) {
593             accessibleChangeSupport = new PropertyChangeSupport(this);
594         }
595         accessibleChangeSupport.addPropertyChangeListener(listener);
596     }
597 
598     /**
599      * Removes a PropertyChangeListener from the listener list.
600      * This removes a PropertyChangeListener that was registered
601      * for all properties.
602      *
603      * @param listener  The PropertyChangeListener to be removed
604      */
605     public void removePropertyChangeListener(PropertyChangeListener listener) {
606         if (accessibleChangeSupport != null) {
607             accessibleChangeSupport.removePropertyChangeListener(listener);
608         }
609     }
610 
611     /**
612      * Gets the AccessibleAction associated with this object that supports
613      * one or more actions.
614      *
615      * @return AccessibleAction if supported by object; else return null
616      * @see AccessibleAction
617      */
618     public AccessibleAction getAccessibleAction() {
619         return null;
620     }
621 
622     /**
623      * Gets the AccessibleComponent associated with this object that has a
624      * graphical representation.
625      *
626      * @return AccessibleComponent if supported by object; else return null
627      * @see AccessibleComponent
628      */
629     public AccessibleComponent getAccessibleComponent() {
630         return null;
631     }
632 
633     /**
634      * Gets the AccessibleSelection associated with this object which allows its
635      * Accessible children to be selected.
636      *
637      * @return AccessibleSelection if supported by object; else return null
638      * @see AccessibleSelection
639      */
640     public AccessibleSelection getAccessibleSelection() {
641         return null;
642     }
643 
644     /**
645      * Gets the AccessibleText associated with this object presenting
646      * text on the display.
647      *
648      * @return AccessibleText if supported by object; else return null
649      * @see AccessibleText
650      */
651     public AccessibleText getAccessibleText() {
652         return null;
653     }
654 
655     /**
656      * Gets the AccessibleEditableText associated with this object
657      * presenting editable text on the display.
658      *
659      * @return AccessibleEditableText if supported by object; else return null
660      * @see AccessibleEditableText
661      * @since 1.4
662      */
663     public AccessibleEditableText getAccessibleEditableText() {
664         return null;
665     }
666 
667 
668     /**
669      * Gets the AccessibleValue associated with this object that supports a
670      * Numerical value.
671      *
672      * @return AccessibleValue if supported by object; else return null
673      * @see AccessibleValue
674      */
675     public AccessibleValue getAccessibleValue() {
676         return null;
677     }
678 
679     /**
680      * Gets the AccessibleIcons associated with an object that has
681      * one or more associated icons
682      *
683      * @return an array of AccessibleIcon if supported by object;
684      * otherwise return null
685      * @see AccessibleIcon
686      * @since 1.3
687      */
688     public AccessibleIcon [] getAccessibleIcon() {
689         return null;
690     }
691 
692     /**
693      * Gets the AccessibleRelationSet associated with an object
694      *
695      * @return an AccessibleRelationSet if supported by object;
696      * otherwise return null
697      * @see AccessibleRelationSet
698      * @since 1.3
699      */
700     public AccessibleRelationSet getAccessibleRelationSet() {
701         return relationSet;
702     }
703 
704     /**
705      * Gets the AccessibleTable associated with an object
706      *
707      * @return an AccessibleTable if supported by object;
708      * otherwise return null
709      * @see AccessibleTable
710      * @since 1.3
711      */
712     public AccessibleTable getAccessibleTable() {
713         return null;
714     }
715 
716     /**
717      * Support for reporting bound property changes.  If oldValue and
718      * newValue are not equal and the PropertyChangeEvent listener list
719      * is not empty, then fire a PropertyChange event to each listener.
720      * In general, this is for use by the Accessible objects themselves
721      * and should not be called by an application program.
722      * @param propertyName  The programmatic name of the property that
723      * was changed.
724      * @param oldValue  The old value of the property.
725      * @param newValue  The new value of the property.
726      * @see java.beans.PropertyChangeSupport
727      * @see #addPropertyChangeListener
728      * @see #removePropertyChangeListener
729      * @see #ACCESSIBLE_NAME_PROPERTY
730      * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
731      * @see #ACCESSIBLE_STATE_PROPERTY
732      * @see #ACCESSIBLE_VALUE_PROPERTY
733      * @see #ACCESSIBLE_SELECTION_PROPERTY
734      * @see #ACCESSIBLE_TEXT_PROPERTY
735      * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
736      */
737     public void firePropertyChange(String propertyName,
738                                    Object oldValue,
739                                    Object newValue) {
740         if (accessibleChangeSupport != null) {
741             if (newValue instanceof PropertyChangeEvent) {
742                 PropertyChangeEvent pce = (PropertyChangeEvent)newValue;
743                 accessibleChangeSupport.firePropertyChange(pce);
744             } else {
745                 accessibleChangeSupport.firePropertyChange(propertyName,
746                                                            oldValue,
747                                                            newValue);
748             }
749         }
750     }
751 }