1 /*
2 * Copyright 1997-2006 Sun Microsystems, Inc. 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. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any 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 #AccessibleText.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 #AccessibleText.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 #AccessibleText.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 /**
398 * Gets the accessibleName property of this object. The accessibleName
399 * property of an object is a localized String that designates the purpose
400 * of the object. For example, the accessibleName property of a label
401 * or button might be the text of the label or button itself. In the
402 * case of an object that doesn't display its name, the accessibleName
403 * should still be set. For example, in the case of a text field used
404 * to enter the name of a city, the accessibleName for the en_US locale
405 * could be 'city.'
406 *
407 * @return the localized name of the object; null if this
408 * object does not have a name
409 *
410 * @see #setAccessibleName
411 */
412 public String getAccessibleName() {
413 return accessibleName;
414 }
415
416 /**
417 * Sets the localized accessible name of this object. Changing the
418 * name will cause a PropertyChangeEvent to be fired for the
419 * ACCESSIBLE_NAME_PROPERTY property.
420 *
421 * @param s the new localized name of the object.
422 *
423 * @see #getAccessibleName
424 * @see #addPropertyChangeListener
425 *
426 * @beaninfo
427 * preferred: true
428 * description: Sets the accessible name for the component.
429 */
430 public void setAccessibleName(String s) {
431 String oldName = accessibleName;
432 accessibleName = s;
433 firePropertyChange(ACCESSIBLE_NAME_PROPERTY,oldName,accessibleName);
434 }
435
436 /**
437 * Gets the accessibleDescription property of this object. The
438 * accessibleDescription property of this object is a short localized
439 * phrase describing the purpose of the object. For example, in the
440 * case of a 'Cancel' button, the accessibleDescription could be
441 * 'Ignore changes and close dialog box.'
442 *
443 * @return the localized description of the object; null if
444 * this object does not have a description
445 *
446 * @see #setAccessibleDescription
447 */
448 public String getAccessibleDescription() {
449 return accessibleDescription;
450 }
451
452 /**
453 * Sets the accessible description of this object. Changing the
454 * name will cause a PropertyChangeEvent to be fired for the
455 * ACCESSIBLE_DESCRIPTION_PROPERTY property.
456 *
457 * @param s the new localized description of the object
458 *
459 * @see #setAccessibleName
460 * @see #addPropertyChangeListener
461 *
462 * @beaninfo
463 * preferred: true
464 * description: Sets the accessible description for the component.
465 */
466 public void setAccessibleDescription(String s) {
467 String oldDescription = accessibleDescription;
468 accessibleDescription = s;
469 firePropertyChange(ACCESSIBLE_DESCRIPTION_PROPERTY,
470 oldDescription,accessibleDescription);
471 }
472
473 /**
474 * Gets the role of this object. The role of the object is the generic
475 * purpose or use of the class of this object. For example, the role
476 * of a push button is AccessibleRole.PUSH_BUTTON. The roles in
477 * AccessibleRole are provided so component developers can pick from
478 * a set of predefined roles. This enables assistive technologies to
479 * provide a consistent interface to various tweaked subclasses of
480 * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
481 * that act like a push button) as well as distinguish between sublasses
482 * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
483 * and AccessibleRole.RADIO_BUTTON for radio buttons).
484 * <p>Note that the AccessibleRole class is also extensible, so
485 * custom component developers can define their own AccessibleRole's
486 * if the set of predefined roles is inadequate.
487 *
488 * @return an instance of AccessibleRole describing the role of the object
489 * @see AccessibleRole
490 */
491 public abstract AccessibleRole getAccessibleRole();
492
493 /**
494 * Gets the state set of this object. The AccessibleStateSet of an object
495 * is composed of a set of unique AccessibleStates. A change in the
496 * AccessibleStateSet of an object will cause a PropertyChangeEvent to
497 * be fired for the ACCESSIBLE_STATE_PROPERTY property.
498 *
499 * @return an instance of AccessibleStateSet containing the
500 * current state set of the object
501 * @see AccessibleStateSet
502 * @see AccessibleState
503 * @see #addPropertyChangeListener
504 */
505 public abstract AccessibleStateSet getAccessibleStateSet();
506
507 /**
508 * Gets the Accessible parent of this object.
509 *
510 * @return the Accessible parent of this object; null if this
511 * object does not have an Accessible parent
512 */
513 public Accessible getAccessibleParent() {
514 return accessibleParent;
515 }
516
517 /**
518 * Sets the Accessible parent of this object. This is meant to be used
519 * only in the situations where the actual component's parent should
520 * not be treated as the component's accessible parent and is a method
521 * that should only be called by the parent of the accessible child.
522 *
523 * @param a - Accessible to be set as the parent
524 */
525 public void setAccessibleParent(Accessible a) {
526 accessibleParent = a;
527 }
528
529 /**
530 * Gets the 0-based index of this object in its accessible parent.
531 *
532 * @return the 0-based index of this object in its parent; -1 if this
533 * object does not have an accessible parent.
534 *
535 * @see #getAccessibleParent
536 * @see #getAccessibleChildrenCount
537 * @see #getAccessibleChild
538 */
539 public abstract int getAccessibleIndexInParent();
540
541 /**
542 * Returns the number of accessible children of the object.
543 *
544 * @return the number of accessible children of the object.
545 */
546 public abstract int getAccessibleChildrenCount();
547
548 /**
549 * Returns the specified Accessible child of the object. The Accessible
550 * children of an Accessible object are zero-based, so the first child
551 * of an Accessible child is at index 0, the second child is at index 1,
552 * and so on.
553 *
554 * @param i zero-based index of child
555 * @return the Accessible child of the object
556 * @see #getAccessibleChildrenCount
557 */
558 public abstract Accessible getAccessibleChild(int i);
559
560 /**
561 * Gets the locale of the component. If the component does not have a
562 * locale, then the locale of its parent is returned.
563 *
564 * @return this component's locale. If this component does not have
565 * a locale, the locale of its parent is returned.
566 *
567 * @exception IllegalComponentStateException
568 * If the Component does not have its own locale and has not yet been
569 * added to a containment hierarchy such that the locale can be
570 * determined from the containing parent.
571 */
572 public abstract Locale getLocale() throws IllegalComponentStateException;
573
574 /**
575 * Adds a PropertyChangeListener to the listener list.
576 * The listener is registered for all Accessible properties and will
577 * be called when those properties change.
578 *
579 * @see #ACCESSIBLE_NAME_PROPERTY
580 * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
581 * @see #ACCESSIBLE_STATE_PROPERTY
582 * @see #ACCESSIBLE_VALUE_PROPERTY
583 * @see #ACCESSIBLE_SELECTION_PROPERTY
584 * @see #ACCESSIBLE_TEXT_PROPERTY
585 * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
586 *
587 * @param listener The PropertyChangeListener to be added
588 */
589 public void addPropertyChangeListener(PropertyChangeListener listener) {
590 if (accessibleChangeSupport == null) {
591 accessibleChangeSupport = new PropertyChangeSupport(this);
592 }
593 accessibleChangeSupport.addPropertyChangeListener(listener);
594 }
595
596 /**
597 * Removes a PropertyChangeListener from the listener list.
598 * This removes a PropertyChangeListener that was registered
599 * for all properties.
600 *
601 * @param listener The PropertyChangeListener to be removed
602 */
603 public void removePropertyChangeListener(PropertyChangeListener listener) {
604 if (accessibleChangeSupport != null) {
605 accessibleChangeSupport.removePropertyChangeListener(listener);
606 }
607 }
608
609 /**
610 * Gets the AccessibleAction associated with this object that supports
611 * one or more actions.
612 *
613 * @return AccessibleAction if supported by object; else return null
614 * @see AccessibleAction
615 */
616 public AccessibleAction getAccessibleAction() {
617 return null;
618 }
619
620 /**
621 * Gets the AccessibleComponent associated with this object that has a
622 * graphical representation.
623 *
624 * @return AccessibleComponent if supported by object; else return null
625 * @see AccessibleComponent
626 */
627 public AccessibleComponent getAccessibleComponent() {
628 return null;
629 }
630
631 /**
632 * Gets the AccessibleSelection associated with this object which allows its
633 * Accessible children to be selected.
634 *
635 * @return AccessibleSelection if supported by object; else return null
636 * @see AccessibleSelection
637 */
638 public AccessibleSelection getAccessibleSelection() {
639 return null;
640 }
641
642 /**
643 * Gets the AccessibleText associated with this object presenting
644 * text on the display.
645 *
646 * @return AccessibleText if supported by object; else return null
647 * @see AccessibleText
648 */
649 public AccessibleText getAccessibleText() {
650 return null;
651 }
652
653 /**
654 * Gets the AccessibleEditableText associated with this object
655 * presenting editable text on the display.
656 *
657 * @return AccessibleEditableText if supported by object; else return null
658 * @see AccessibleEditableText
659 * @since 1.4
660 */
661 public AccessibleEditableText getAccessibleEditableText() {
662 return null;
663 }
664
665
666 /**
667 * Gets the AccessibleValue associated with this object that supports a
668 * Numerical value.
669 *
670 * @return AccessibleValue if supported by object; else return null
671 * @see AccessibleValue
672 */
673 public AccessibleValue getAccessibleValue() {
674 return null;
675 }
676
677 /**
678 * Gets the AccessibleIcons associated with an object that has
679 * one or more associated icons
680 *
681 * @return an array of AccessibleIcon if supported by object;
682 * otherwise return null
683 * @see AccessibleIcon
684 * @since 1.3
685 */
686 public AccessibleIcon [] getAccessibleIcon() {
687 return null;
688 }
689
690 /**
691 * Gets the AccessibleRelationSet associated with an object
692 *
693 * @return an AccessibleRelationSet if supported by object;
694 * otherwise return null
695 * @see AccessibleRelationSet
696 * @since 1.3
697 */
698 public AccessibleRelationSet getAccessibleRelationSet() {
699 return relationSet;
700 }
701
702 /**
703 * Gets the AccessibleTable associated with an object
704 *
705 * @return an AccessibleTable if supported by object;
706 * otherwise return null
707 * @see AccessibleTable
708 * @since 1.3
709 */
710 public AccessibleTable getAccessibleTable() {
711 return null;
712 }
713
714 /**
715 * Support for reporting bound property changes. If oldValue and
716 * newValue are not equal and the PropertyChangeEvent listener list
717 * is not empty, then fire a PropertyChange event to each listener.
718 * In general, this is for use by the Accessible objects themselves
719 * and should not be called by an application program.
720 * @param propertyName The programmatic name of the property that
721 * was changed.
722 * @param oldValue The old value of the property.
723 * @param newValue The new value of the property.
724 * @see java.beans.PropertyChangeSupport
725 * @see #addPropertyChangeListener
726 * @see #removePropertyChangeListener
727 * @see #ACCESSIBLE_NAME_PROPERTY
728 * @see #ACCESSIBLE_DESCRIPTION_PROPERTY
729 * @see #ACCESSIBLE_STATE_PROPERTY
730 * @see #ACCESSIBLE_VALUE_PROPERTY
731 * @see #ACCESSIBLE_SELECTION_PROPERTY
732 * @see #ACCESSIBLE_TEXT_PROPERTY
733 * @see #ACCESSIBLE_VISIBLE_DATA_PROPERTY
734 */
735 public void firePropertyChange(String propertyName,
736 Object oldValue,
737 Object newValue) {
738 if (accessibleChangeSupport != null) {
739 if (newValue instanceof PropertyChangeEvent) {
740 PropertyChangeEvent pce = (PropertyChangeEvent)newValue;
741 accessibleChangeSupport.firePropertyChange(pce);
742 } else {
743 accessibleChangeSupport.firePropertyChange(propertyName,
744 oldValue,
745 newValue);
746 }
747 }
748 }
749 }