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