History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/javax/swing/text/html/AccessibleHTML.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/text/html/AccessibleHTML.java+3058−0
@@ -0,0 +1,3058 @@
1/*
2 * Copyright (c) 2000, 2008, 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
26package javax.swing.text.html;
27
28import java.awt.*;
29import java.awt.event.*;
30import java.beans.*;
31import java.util.*;
32import javax.swing.*;
33import javax.swing.event.*;
34import javax.swing.text.*;
35import javax.accessibility.*;
36import java.text.BreakIterator;
37
38/*
39 * The AccessibleHTML class provide information about the contents
40 * of a HTML document to assistive technologies.
41 *
42 * @author Lynn Monsanto
43 */
44class AccessibleHTML implements Accessible {
45
46 /**
47 * The editor.
48 */
49 private JEditorPane editor;
50 /**
51 * Current model.
52 */
53 private Document model;
54 /**
55 * DocumentListener installed on the current model.
56 */
57 private DocumentListener docListener;
58 /**
59 * PropertyChangeListener installed on the editor
60 */
61 private PropertyChangeListener propChangeListener;
62 /**
63 * The root ElementInfo for the document
64 */
65 private ElementInfo rootElementInfo;
66 /*
67 * The root accessible context for the document
68 */
69 private RootHTMLAccessibleContext rootHTMLAccessibleContext;
70
71 public AccessibleHTML(JEditorPane pane) {
72 editor = pane;
73 propChangeListener = new PropertyChangeHandler();
74 setDocument(editor.getDocument());
75
76 docListener = new DocumentHandler();
77 }
78
79 /**
80 * Sets the document.
81 */
82 private void setDocument(Document document) {
83 if (model != null) {
84 model.removeDocumentListener(docListener);
85 }
86 if (editor != null) {
87 editor.removePropertyChangeListener(propChangeListener);
88 }
89 this.model = document;
90 if (model != null) {
91 if (rootElementInfo != null) {
92 rootElementInfo.invalidate(false);
93 }
94 buildInfo();
95 model.addDocumentListener(docListener);
96 }
97 else {
98 rootElementInfo = null;
99 }
100 if (editor != null) {
101 editor.addPropertyChangeListener(propChangeListener);
102 }
103 }
104
105 /**
106 * Returns the Document currently presenting information for.
107 */
108 private Document getDocument() {
109 return model;
110 }
111
112 /**
113 * Returns the JEditorPane providing information for.
114 */
115 private JEditorPane getTextComponent() {
116 return editor;
117 }
118
119 /**
120 * Returns the ElementInfo representing the root Element.
121 */
122 private ElementInfo getRootInfo() {
123 return rootElementInfo;
124 }
125
126 /**
127 * Returns the root <code>View</code> associated with the current text
128 * component.
129 */
130 private View getRootView() {
131 return getTextComponent().getUI().getRootView(getTextComponent());
132 }
133
134 /**
135 * Returns the bounds the root View will be rendered in.
136 */
137 private Rectangle getRootEditorRect() {
138 Rectangle alloc = getTextComponent().getBounds();
139 if ((alloc.width > 0) && (alloc.height > 0)) {
140 alloc.x = alloc.y = 0;
141 Insets insets = editor.getInsets();
142 alloc.x += insets.left;
143 alloc.y += insets.top;
144 alloc.width -= insets.left + insets.right;
145 alloc.height -= insets.top + insets.bottom;
146 return alloc;
147 }
148 return null;
149 }
150
151 /**
152 * If possible acquires a lock on the Document. If a lock has been
153 * obtained a key will be retured that should be passed to
154 * <code>unlock</code>.
155 */
156 private Object lock() {
157 Document document = getDocument();
158
159 if (document instanceof AbstractDocument) {
160 ((AbstractDocument)document).readLock();
161 return document;
162 }
163 return null;
164 }
165
166 /**
167 * Releases a lock previously obtained via <code>lock</code>.
168 */
169 private void unlock(Object key) {
170 if (key != null) {
171 ((AbstractDocument)key).readUnlock();
172 }
173 }
174
175 /**
176 * Rebuilds the information from the current info.
177 */
178 private void buildInfo() {
179 Object lock = lock();
180
181 try {
182 Document doc = getDocument();
183 Element root = doc.getDefaultRootElement();
184
185 rootElementInfo = new ElementInfo(root);
186 rootElementInfo.validate();
187 } finally {
188 unlock(lock);
189 }
190 }
191
192 /*
193 * Create an ElementInfo subclass based on the passed in Element.
194 */
195 ElementInfo createElementInfo(Element e, ElementInfo parent) {
196 AttributeSet attrs = e.getAttributes();
197
198 if (attrs != null) {
199 Object name = attrs.getAttribute(StyleConstants.NameAttribute);
200
201 if (name == HTML.Tag.IMG) {
202 return new IconElementInfo(e, parent);
203 }
204 else if (name == HTML.Tag.CONTENT || name == HTML.Tag.CAPTION) {
205 return new TextElementInfo(e, parent);
206 }
207 else if (name == HTML.Tag.TABLE) {
208 return new TableElementInfo(e, parent);
209 }
210 }
211 return null;
212 }
213
214 /**
215 * Returns the root AccessibleContext for the document
216 */
217 public AccessibleContext getAccessibleContext() {
218 if (rootHTMLAccessibleContext == null) {
219 rootHTMLAccessibleContext =
220 new RootHTMLAccessibleContext(rootElementInfo);
221 }
222 return rootHTMLAccessibleContext;
223 }
224
225 /*
226 * The roow AccessibleContext for the document
227 */
228 private class RootHTMLAccessibleContext extends HTMLAccessibleContext {
229
230 public RootHTMLAccessibleContext(ElementInfo elementInfo) {
231 super(elementInfo);
232 }
233
234 /**
235 * Gets the accessibleName property of this object. The accessibleName
236 * property of an object is a localized String that designates the purpose
237 * of the object. For example, the accessibleName property of a label
238 * or button might be the text of the label or button itself. In the
239 * case of an object that doesn't display its name, the accessibleName
240 * should still be set. For example, in the case of a text field used
241 * to enter the name of a city, the accessibleName for the en_US locale
242 * could be 'city.'
243 *
244 * @return the localized name of the object; null if this
245 * object does not have a name
246 *
247 * @see #setAccessibleName
248 */
249 public String getAccessibleName() {
250 if (model != null) {
251 return (String)model.getProperty(Document.TitleProperty);
252 } else {
253 return null;
254 }
255 }
256
257 /**
258 * Gets the accessibleDescription property of this object. If this
259 * property isn't set, returns the content type of this
260 * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text").
261 *
262 * @return the localized description of the object; <code>null</code>
263 * if this object does not have a description
264 *
265 * @see #setAccessibleName
266 */
267 public String getAccessibleDescription() {
268 return editor.getContentType();
269 }
270
271 /**
272 * Gets the role of this object. The role of the object is the generic
273 * purpose or use of the class of this object. For example, the role
274 * of a push button is AccessibleRole.PUSH_BUTTON. The roles in
275 * AccessibleRole are provided so component developers can pick from
276 * a set of predefined roles. This enables assistive technologies to
277 * provide a consistent interface to various tweaked subclasses of
278 * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
279 * that act like a push button) as well as distinguish between sublasses
280 * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
281 * and AccessibleRole.RADIO_BUTTON for radio buttons).
282 * <p>Note that the AccessibleRole class is also extensible, so
283 * custom component developers can define their own AccessibleRole's
284 * if the set of predefined roles is inadequate.
285 *
286 * @return an instance of AccessibleRole describing the role of the object
287 * @see AccessibleRole
288 */
289 public AccessibleRole getAccessibleRole() {
290 return AccessibleRole.TEXT;
291 }
292 }
293
294 /*
295 * Base AccessibleContext class for HTML elements
296 */
297 protected abstract class HTMLAccessibleContext extends AccessibleContext
298 implements Accessible, AccessibleComponent {
299
300 protected ElementInfo elementInfo;
301
302 public HTMLAccessibleContext(ElementInfo elementInfo) {
303 this.elementInfo = elementInfo;
304 }
305
306 // begin AccessibleContext implementation ...
307 public AccessibleContext getAccessibleContext() {
308 return this;
309 }
310
311 /**
312 * Gets the state set of this object.
313 *
314 * @return an instance of AccessibleStateSet describing the states
315 * of the object
316 * @see AccessibleStateSet
317 */
318 public AccessibleStateSet getAccessibleStateSet() {
319 AccessibleStateSet states = new AccessibleStateSet();
320 Component comp = getTextComponent();
321
322 if (comp.isEnabled()) {
323 states.add(AccessibleState.ENABLED);
324 }
325 if (comp instanceof JTextComponent &&
326 ((JTextComponent)comp).isEditable()) {
327
328 states.add(AccessibleState.EDITABLE);
329 states.add(AccessibleState.FOCUSABLE);
330 }
331 if (comp.isVisible()) {
332 states.add(AccessibleState.VISIBLE);
333 }
334 if (comp.isShowing()) {
335 states.add(AccessibleState.SHOWING);
336 }
337 return states;
338 }
339
340 /**
341 * Gets the 0-based index of this object in its accessible parent.
342 *
343 * @return the 0-based index of this object in its parent; -1 if this
344 * object does not have an accessible parent.
345 *
346 * @see #getAccessibleParent
347 * @see #getAccessibleChildrenCount
348 * @see #getAccessibleChild
349 */
350 public int getAccessibleIndexInParent() {
351 return elementInfo.getIndexInParent();
352 }
353
354 /**
355 * Returns the number of accessible children of the object.
356 *
357 * @return the number of accessible children of the object.
358 */
359 public int getAccessibleChildrenCount() {
360 return elementInfo.getChildCount();
361 }
362
363 /**
364 * Returns the specified Accessible child of the object. The Accessible
365 * children of an Accessible object are zero-based, so the first child
366 * of an Accessible child is at index 0, the second child is at index 1,
367 * and so on.
368 *
369 * @param i zero-based index of child
370 * @return the Accessible child of the object
371 * @see #getAccessibleChildrenCount
372 */
373 public Accessible getAccessibleChild(int i) {
374 ElementInfo childInfo = elementInfo.getChild(i);
375 if (childInfo != null && childInfo instanceof Accessible) {
376 return (Accessible)childInfo;
377 } else {
378 return null;
379 }
380 }
381
382 /**
383 * Gets the locale of the component. If the component does not have a
384 * locale, then the locale of its parent is returned.
385 *
386 * @return this component's locale. If this component does not have
387 * a locale, the locale of its parent is returned.
388 *
389 * @exception IllegalComponentStateException
390 * If the Component does not have its own locale and has not yet been
391 * added to a containment hierarchy such that the locale can be
392 * determined from the containing parent.
393 */
394 public Locale getLocale() throws IllegalComponentStateException {
395 return editor.getLocale();
396 }
397 // ... end AccessibleContext implementation
398
399 // begin AccessibleComponent implementation ...
400 public AccessibleComponent getAccessibleComponent() {
401 return this;
402 }
403
404 /**
405 * Gets the background color of this object.
406 *
407 * @return the background color, if supported, of the object;
408 * otherwise, null
409 * @see #setBackground
410 */
411 public Color getBackground() {
412 return getTextComponent().getBackground();
413 }
414
415 /**
416 * Sets the background color of this object.
417 *
418 * @param c the new Color for the background
419 * @see #setBackground
420 */
421 public void setBackground(Color c) {
422 getTextComponent().setBackground(c);
423 }
424
425 /**
426 * Gets the foreground color of this object.
427 *
428 * @return the foreground color, if supported, of the object;
429 * otherwise, null
430 * @see #setForeground
431 */
432 public Color getForeground() {
433 return getTextComponent().getForeground();
434 }
435
436 /**
437 * Sets the foreground color of this object.
438 *
439 * @param c the new Color for the foreground
440 * @see #getForeground
441 */
442 public void setForeground(Color c) {
443 getTextComponent().setForeground(c);
444 }
445
446 /**
447 * Gets the Cursor of this object.
448 *
449 * @return the Cursor, if supported, of the object; otherwise, null
450 * @see #setCursor
451 */
452 public Cursor getCursor() {
453 return getTextComponent().getCursor();
454 }
455
456 /**
457 * Sets the Cursor of this object.
458 *
459 * @param cursor the new Cursor for the object
460 * @see #getCursor
461 */
462 public void setCursor(Cursor cursor) {
463 getTextComponent().setCursor(cursor);
464 }
465
466 /**
467 * Gets the Font of this object.
468 *
469 * @return the Font,if supported, for the object; otherwise, null
470 * @see #setFont
471 */
472 public Font getFont() {
473 return getTextComponent().getFont();
474 }
475
476 /**
477 * Sets the Font of this object.
478 *
479 * @param f the new Font for the object
480 * @see #getFont
481 */
482 public void setFont(Font f) {
483 getTextComponent().setFont(f);
484 }
485
486 /**
487 * Gets the FontMetrics of this object.
488 *
489 * @param f the Font
490 * @return the FontMetrics, if supported, the object; otherwise, null
491 * @see #getFont
492 */
493 public FontMetrics getFontMetrics(Font f) {
494 return getTextComponent().getFontMetrics(f);
495 }
496
497 /**
498 * Determines if the object is enabled. Objects that are enabled
499 * will also have the AccessibleState.ENABLED state set in their
500 * AccessibleStateSets.
501 *
502 * @return true if object is enabled; otherwise, false
503 * @see #setEnabled
504 * @see AccessibleContext#getAccessibleStateSet
505 * @see AccessibleState#ENABLED
506 * @see AccessibleStateSet
507 */
508 public boolean isEnabled() {
509 return getTextComponent().isEnabled();
510 }
511
512 /**
513 * Sets the enabled state of the object.
514 *
515 * @param b if true, enables this object; otherwise, disables it
516 * @see #isEnabled
517 */
518 public void setEnabled(boolean b) {
519 getTextComponent().setEnabled(b);
520 }
521
522 /**
523 * Determines if the object is visible. Note: this means that the
524 * object intends to be visible; however, it may not be
525 * showing on the screen because one of the objects that this object
526 * is contained by is currently not visible. To determine if an object
527 * is showing on the screen, use isShowing().
528 * <p>Objects that are visible will also have the
529 * AccessibleState.VISIBLE state set in their AccessibleStateSets.
530 *
531 * @return true if object is visible; otherwise, false
532 * @see #setVisible
533 * @see AccessibleContext#getAccessibleStateSet
534 * @see AccessibleState#VISIBLE
535 * @see AccessibleStateSet
536 */
537 public boolean isVisible() {
538 return getTextComponent().isVisible();
539 }
540
541 /**
542 * Sets the visible state of the object.
543 *
544 * @param b if true, shows this object; otherwise, hides it
545 * @see #isVisible
546 */
547 public void setVisible(boolean b) {
548 getTextComponent().setVisible(b);
549 }
550
551 /**
552 * Determines if the object is showing. This is determined by checking
553 * the visibility of the object and its ancestors.
554 * Note: this
555 * will return true even if the object is obscured by another (for
556 * example, it is underneath a menu that was pulled down).
557 *
558 * @return true if object is showing; otherwise, false
559 */
560 public boolean isShowing() {
561 return getTextComponent().isShowing();
562 }
563
564 /**
565 * Checks whether the specified point is within this object's bounds,
566 * where the point's x and y coordinates are defined to be relative
567 * to the coordinate system of the object.
568 *
569 * @param p the Point relative to the coordinate system of the object
570 * @return true if object contains Point; otherwise false
571 * @see #getBounds
572 */
573 public boolean contains(Point p) {
574 Rectangle r = getBounds();
575 if (r != null) {
576 return r.contains(p.x, p.y);
577 } else {
578 return false;
579 }
580 }
581
582 /**
583 * Returns the location of the object on the screen.
584 *
585 * @return the location of the object on screen; null if this object
586 * is not on the screen
587 * @see #getBounds
588 * @see #getLocation
589 */
590 public Point getLocationOnScreen() {
591 Point editorLocation = getTextComponent().getLocationOnScreen();
592 Rectangle r = getBounds();
593 if (r != null) {
594 return new Point(editorLocation.x + r.x,
595 editorLocation.y + r.y);
596 } else {
597 return null;
598 }
599 }
600
601 /**
602 * Gets the location of the object relative to the parent in the form
603 * of a point specifying the object's top-left corner in the screen's
604 * coordinate space.
605 *
606 * @return An instance of Point representing the top-left corner of the
607 * object's bounds in the coordinate space of the screen; null if
608 * this object or its parent are not on the screen
609 * @see #getBounds
610 * @see #getLocationOnScreen
611 */
612 public Point getLocation() {
613 Rectangle r = getBounds();
614 if (r != null) {
615 return new Point(r.x, r.y);
616 } else {
617 return null;
618 }
619 }
620
621 /**
622 * Sets the location of the object relative to the parent.
623 * @param p the new position for the top-left corner
624 * @see #getLocation
625 */
626 public void setLocation(Point p) {
627 }
628
629 /**
630 * Gets the bounds of this object in the form of a Rectangle object.
631 * The bounds specify this object's width, height, and location
632 * relative to its parent.
633 *
634 * @return A rectangle indicating this component's bounds; null if
635 * this object is not on the screen.
636 * @see #contains
637 */
638 public Rectangle getBounds() {
639 return elementInfo.getBounds();
640 }
641
642 /**
643 * Sets the bounds of this object in the form of a Rectangle object.
644 * The bounds specify this object's width, height, and location
645 * relative to its parent.
646 *
647 * @param r rectangle indicating this component's bounds
648 * @see #getBounds
649 */
650 public void setBounds(Rectangle r) {
651 }
652
653 /**
654 * Returns the size of this object in the form of a Dimension object.
655 * The height field of the Dimension object contains this object's
656 * height, and the width field of the Dimension object contains this
657 * object's width.
658 *
659 * @return A Dimension object that indicates the size of this component;
660 * null if this object is not on the screen
661 * @see #setSize
662 */
663 public Dimension getSize() {
664 Rectangle r = getBounds();
665 if (r != null) {
666 return new Dimension(r.width, r.height);
667 } else {
668 return null;
669 }
670 }
671
672 /**
673 * Resizes this object so that it has width and height.
674 *
675 * @param d The dimension specifying the new size of the object.
676 * @see #getSize
677 */
678 public void setSize(Dimension d) {
679 Component comp = getTextComponent();
680 comp.setSize(d);
681 }
682
683 /**
684 * Returns the Accessible child, if one exists, contained at the local
685 * coordinate Point.
686 *
687 * @param p The point relative to the coordinate system of this object.
688 * @return the Accessible, if it exists, at the specified location;
689 * otherwise null
690 */
691 public Accessible getAccessibleAt(Point p) {
692 ElementInfo innerMostElement = getElementInfoAt(rootElementInfo, p);
693 if (innerMostElement instanceof Accessible) {
694 return (Accessible)innerMostElement;
695 } else {
696 return null;
697 }
698 }
699
700 private ElementInfo getElementInfoAt(ElementInfo elementInfo, Point p) {
701 if (elementInfo.getBounds() == null) {
702 return null;
703 }
704 if (elementInfo.getChildCount() == 0 &&
705 elementInfo.getBounds().contains(p)) {
706 return elementInfo;
707
708 } else {
709 if (elementInfo instanceof TableElementInfo) {
710 // Handle table caption as a special case since it's the
711 // only table child that is not a table row.
712 ElementInfo captionInfo =
713 ((TableElementInfo)elementInfo).getCaptionInfo();
714 if (captionInfo != null) {
715 Rectangle bounds = captionInfo.getBounds();
716 if (bounds != null && bounds.contains(p)) {
717 return captionInfo;
718 }
719 }
720 }
721 for (int i = 0; i < elementInfo.getChildCount(); i++)
722{
723 ElementInfo childInfo = elementInfo.getChild(i);
724 ElementInfo retValue = getElementInfoAt(childInfo, p);
725 if (retValue != null) {
726 return retValue;
727 }
728 }
729 }
730 return null;
731 }
732
733 /**
734 * Returns whether this object can accept focus or not. Objects that
735 * can accept focus will also have the AccessibleState.FOCUSABLE state
736 * set in their AccessibleStateSets.
737 *
738 * @return true if object can accept focus; otherwise false
739 * @see AccessibleContext#getAccessibleStateSet
740 * @see AccessibleState#FOCUSABLE
741 * @see AccessibleState#FOCUSED
742 * @see AccessibleStateSet
743 */
744 public boolean isFocusTraversable() {
745 Component comp = getTextComponent();
746 if (comp instanceof JTextComponent) {
747 if (((JTextComponent)comp).isEditable()) {
748 return true;
749 }
750 }
751 return false;
752 }
753
754 /**
755 * Requests focus for this object. If this object cannot accept focus,
756 * nothing will happen. Otherwise, the object will attempt to take
757 * focus.
758 * @see #isFocusTraversable
759 */
760 public void requestFocus() {
761 // TIGER - 4856191
762 if (! isFocusTraversable()) {
763 return;
764 }
765
766 Component comp = getTextComponent();
767 if (comp instanceof JTextComponent) {
768
769 comp.requestFocusInWindow();
770
771 try {
772 if (elementInfo.validateIfNecessary()) {
773 // set the caret position to the start of this component
774 Element elem = elementInfo.getElement();
775 ((JTextComponent)comp).setCaretPosition(elem.getStartOffset());
776
777 // fire a AccessibleState.FOCUSED property change event
778 AccessibleContext ac = editor.getAccessibleContext();
779 PropertyChangeEvent pce = new PropertyChangeEvent(this,
780 AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
781 null, AccessibleState.FOCUSED);
782 ac.firePropertyChange(
783 AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
784 null, pce);
785 }
786 } catch (IllegalArgumentException e) {
787 // don't fire property change event
788 }
789 }
790 }
791
792 /**
793 * Adds the specified focus listener to receive focus events from this
794 * component.
795 *
796 * @param l the focus listener
797 * @see #removeFocusListener
798 */
799 public void addFocusListener(FocusListener l) {
800 getTextComponent().addFocusListener(l);
801 }
802
803 /**
804 * Removes the specified focus listener so it no longer receives focus
805 * events from this component.
806 *
807 * @param l the focus listener
808 * @see #addFocusListener
809 */
810 public void removeFocusListener(FocusListener l) {
811 getTextComponent().removeFocusListener(l);
812 }
813 // ... end AccessibleComponent implementation
814 } // ... end HTMLAccessibleContext
815
816
817
818 /*
819 * ElementInfo for text
820 */
821 class TextElementInfo extends ElementInfo implements Accessible {
822
823 TextElementInfo(Element element, ElementInfo parent) {
824 super(element, parent);
825 }
826
827 // begin AccessibleText implementation ...
828 private AccessibleContext accessibleContext;
829
830 public AccessibleContext getAccessibleContext() {
831 if (accessibleContext == null) {
832 accessibleContext = new TextAccessibleContext(this);
833 }
834 return accessibleContext;
835 }
836
837 /*
838 * AccessibleContext for text elements
839 */
840 public class TextAccessibleContext extends HTMLAccessibleContext
841 implements AccessibleText {
842
843 public TextAccessibleContext(ElementInfo elementInfo) {
844 super(elementInfo);
845 }
846
847 public AccessibleText getAccessibleText() {
848 return this;
849 }
850
851 /**
852 * Gets the accessibleName property of this object. The accessibleName
853 * property of an object is a localized String that designates the purpose
854 * of the object. For example, the accessibleName property of a label
855 * or button might be the text of the label or button itself. In the
856 * case of an object that doesn't display its name, the accessibleName
857 * should still be set. For example, in the case of a text field used
858 * to enter the name of a city, the accessibleName for the en_US locale
859 * could be 'city.'
860 *
861 * @return the localized name of the object; null if this
862 * object does not have a name
863 *
864 * @see #setAccessibleName
865 */
866 public String getAccessibleName() {
867 if (model != null) {
868 return (String)model.getProperty(Document.TitleProperty);
869 } else {
870 return null;
871 }
872 }
873
874 /**
875 * Gets the accessibleDescription property of this object. If this
876 * property isn't set, returns the content type of this
877 * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text").
878 *
879 * @return the localized description of the object; <code>null</code>
880 * if this object does not have a description
881 *
882 * @see #setAccessibleName
883 */
884 public String getAccessibleDescription() {
885 return editor.getContentType();
886 }
887
888 /**
889 * Gets the role of this object. The role of the object is the generic
890 * purpose or use of the class of this object. For example, the role
891 * of a push button is AccessibleRole.PUSH_BUTTON. The roles in
892 * AccessibleRole are provided so component developers can pick from
893 * a set of predefined roles. This enables assistive technologies to
894 * provide a consistent interface to various tweaked subclasses of
895 * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
896 * that act like a push button) as well as distinguish between sublasses
897 * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
898 * and AccessibleRole.RADIO_BUTTON for radio buttons).
899 * <p>Note that the AccessibleRole class is also extensible, so
900 * custom component developers can define their own AccessibleRole's
901 * if the set of predefined roles is inadequate.
902 *
903 * @return an instance of AccessibleRole describing the role of the object
904 * @see AccessibleRole
905 */
906 public AccessibleRole getAccessibleRole() {
907 return AccessibleRole.TEXT;
908 }
909
910 /**
911 * Given a point in local coordinates, return the zero-based index
912 * of the character under that Point. If the point is invalid,
913 * this method returns -1.
914 *
915 * @param p the Point in local coordinates
916 * @return the zero-based index of the character under Point p; if
917 * Point is invalid returns -1.
918 */
919 public int getIndexAtPoint(Point p) {
920 View v = getView();
921 if (v != null) {
922 return v.viewToModel(p.x, p.y, getBounds());
923 } else {
924 return -1;
925 }
926 }
927
928 /**
929 * Determine the bounding box of the character at the given
930 * index into the string. The bounds are returned in local
931 * coordinates. If the index is invalid an empty rectangle is
932 * returned.
933 *
934 * @param i the index into the String
935 * @return the screen coordinates of the character's the bounding box,
936 * if index is invalid returns an empty rectangle.
937 */
938 public Rectangle getCharacterBounds(int i) {
939 try {
940 return editor.getUI().modelToView(editor, i);
941 } catch (BadLocationException e) {
942 return null;
943 }
944 }
945
946 /**
947 * Return the number of characters (valid indicies)
948 *
949 * @return the number of characters
950 */
951 public int getCharCount() {
952 if (validateIfNecessary()) {
953 Element elem = elementInfo.getElement();
954 return elem.getEndOffset() - elem.getStartOffset();
955 }
956 return 0;
957 }
958
959 /**
960 * Return the zero-based offset of the caret.
961 *
962 * Note: That to the right of the caret will have the same index
963 * value as the offset (the caret is between two characters).
964 * @return the zero-based offset of the caret.
965 */
966 public int getCaretPosition() {
967 View v = getView();
968 if (v == null) {
969 return -1;
970 }
971 Container c = v.getContainer();
972 if (c == null) {
973 return -1;
974 }
975 if (c instanceof JTextComponent) {
976 return ((JTextComponent)c).getCaretPosition();
977 } else {
978 return -1;
979 }
980 }
981
982 /**
983 * IndexedSegment extends Segment adding the offset into the
984 * the model the <code>Segment</code> was asked for.
985 */
986 private class IndexedSegment extends Segment {
987 /**
988 * Offset into the model that the position represents.
989 */
990 public int modelOffset;
991 }
992
993 public String getAtIndex(int part, int index) {
994 return getAtIndex(part, index, 0);
995 }
996
997
998 public String getAfterIndex(int part, int index) {
999 return getAtIndex(part, index, 1);
1000 }
1001
1002 public String getBeforeIndex(int part, int index) {
1003 return getAtIndex(part, index, -1);
1004 }
1005
1006 /**
1007 * Gets the word, sentence, or character at <code>index</code>.
1008 * If <code>direction</code> is non-null this will find the
1009 * next/previous word/sentence/character.
1010 */
1011 private String getAtIndex(int part, int index, int direction) {
1012 if (model instanceof AbstractDocument) {
1013 ((AbstractDocument)model).readLock();
1014 }
1015 try {
1016 if (index < 0 || index >= model.getLength()) {
1017 return null;
1018 }
1019 switch (part) {
1020 case AccessibleText.CHARACTER:
1021 if (index + direction < model.getLength() &&
1022 index + direction >= 0) {
1023 return model.getText(index + direction, 1);
1024 }
1025 break;
1026
1027
1028 case AccessibleText.WORD:
1029 case AccessibleText.SENTENCE:
1030 IndexedSegment seg = getSegmentAt(part, index);
1031 if (seg != null) {
1032 if (direction != 0) {
1033 int next;
1034
1035
1036 if (direction < 0) {
1037 next = seg.modelOffset - 1;
1038 }
1039 else {
1040 next = seg.modelOffset + direction * seg.count;
1041 }
1042 if (next >= 0 && next <= model.getLength()) {
1043 seg = getSegmentAt(part, next);
1044 }
1045 else {
1046 seg = null;
1047 }
1048 }
1049 if (seg != null) {
1050 return new String(seg.array, seg.offset,
1051 seg.count);
1052 }
1053 }
1054 break;
1055
1056 default:
1057 break;
1058 }
1059 } catch (BadLocationException e) {
1060 } finally {
1061 if (model instanceof AbstractDocument) {
1062 ((AbstractDocument)model).readUnlock();
1063 }
1064 }
1065 return null;
1066 }
1067
1068 /*
1069 * Returns the paragraph element for the specified index.
1070 */
1071 private Element getParagraphElement(int index) {
1072 if (model instanceof PlainDocument ) {
1073 PlainDocument sdoc = (PlainDocument)model;
1074 return sdoc.getParagraphElement(index);
1075 } else if (model instanceof StyledDocument) {
1076 StyledDocument sdoc = (StyledDocument)model;
1077 return sdoc.getParagraphElement(index);
1078 } else {
1079 Element para;
1080 for (para = model.getDefaultRootElement(); ! para.isLeaf(); ) {
1081 int pos = para.getElementIndex(index);
1082 para = para.getElement(pos);
1083 }
1084 if (para == null) {
1085 return null;
1086 }
1087 return para.getParentElement();
1088 }
1089 }
1090
1091 /*
1092 * Returns a <code>Segment</code> containing the paragraph text
1093 * at <code>index</code>, or null if <code>index</code> isn't
1094 * valid.
1095 */
1096 private IndexedSegment getParagraphElementText(int index)
1097 throws BadLocationException {
1098 Element para = getParagraphElement(index);
1099
1100
1101 if (para != null) {
1102 IndexedSegment segment = new IndexedSegment();
1103 try {
1104 int length = para.getEndOffset() - para.getStartOffset();
1105 model.getText(para.getStartOffset(), length, segment);
1106 } catch (BadLocationException e) {
1107 return null;
1108 }
1109 segment.modelOffset = para.getStartOffset();
1110 return segment;
1111 }
1112 return null;
1113 }
1114
1115
1116 /**
1117 * Returns the Segment at <code>index</code> representing either
1118 * the paragraph or sentence as identified by <code>part</code>, or
1119 * null if a valid paragraph/sentence can't be found. The offset
1120 * will point to the start of the word/sentence in the array, and
1121 * the modelOffset will point to the location of the word/sentence
1122 * in the model.
1123 */
1124 private IndexedSegment getSegmentAt(int part, int index)
1125 throws BadLocationException {
1126
1127 IndexedSegment seg = getParagraphElementText(index);
1128 if (seg == null) {
1129 return null;
1130 }
1131 BreakIterator iterator;
1132 switch (part) {
1133 case AccessibleText.WORD:
1134 iterator = BreakIterator.getWordInstance(getLocale());
1135 break;
1136 case AccessibleText.SENTENCE:
1137 iterator = BreakIterator.getSentenceInstance(getLocale());
1138 break;
1139 default:
1140 return null;
1141 }
1142 seg.first();
1143 iterator.setText(seg);
1144 int end = iterator.following(index - seg.modelOffset + seg.offset);
1145 if (end == BreakIterator.DONE) {
1146 return null;
1147 }
1148 if (end > seg.offset + seg.count) {
1149 return null;
1150 }
1151 int begin = iterator.previous();
1152 if (begin == BreakIterator.DONE ||
1153 begin >= seg.offset + seg.count) {
1154 return null;
1155 }
1156 seg.modelOffset = seg.modelOffset + begin - seg.offset;
1157 seg.offset = begin;
1158 seg.count = end - begin;
1159 return seg;
1160 }
1161
1162 /**
1163 * Return the AttributeSet for a given character at a given index
1164 *
1165 * @param i the zero-based index into the text
1166 * @return the AttributeSet of the character
1167 */
1168 public AttributeSet getCharacterAttribute(int i) {
1169 if (model instanceof StyledDocument) {
1170 StyledDocument doc = (StyledDocument)model;
1171 Element elem = doc.getCharacterElement(i);
1172 if (elem != null) {
1173 return elem.getAttributes();
1174 }
1175 }
1176 return null;
1177 }
1178
1179 /**
1180 * Returns the start offset within the selected text.
1181 * If there is no selection, but there is
1182 * a caret, the start and end offsets will be the same.
1183 *
1184 * @return the index into the text of the start of the selection
1185 */
1186 public int getSelectionStart() {
1187 return editor.getSelectionStart();
1188 }
1189
1190 /**
1191 * Returns the end offset within the selected text.
1192 * If there is no selection, but there is
1193 * a caret, the start and end offsets will be the same.
1194 *
1195 * @return the index into teh text of the end of the selection
1196 */
1197 public int getSelectionEnd() {
1198 return editor.getSelectionEnd();
1199 }
1200
1201 /**
1202 * Returns the portion of the text that is selected.
1203 *
1204 * @return the String portion of the text that is selected
1205 */
1206 public String getSelectedText() {
1207 return editor.getSelectedText();
1208 }
1209
1210 /*
1211 * Returns the text substring starting at the specified
1212 * offset with the specified length.
1213 */
1214 private String getText(int offset, int length)
1215 throws BadLocationException {
1216
1217 if (model != null && model instanceof StyledDocument) {
1218 StyledDocument doc = (StyledDocument)model;
1219 return model.getText(offset, length);
1220 } else {
1221 return null;
1222 }
1223 }
1224 }
1225 }
1226
1227 /*
1228 * ElementInfo for images
1229 */
1230 private class IconElementInfo extends ElementInfo implements Accessible {
1231
1232 private int width = -1;
1233 private int height = -1;
1234
1235 IconElementInfo(Element element, ElementInfo parent) {
1236 super(element, parent);
1237 }
1238
1239 protected void invalidate(boolean first) {
1240 super.invalidate(first);
1241 width = height = -1;
1242 }
1243
1244 private int getImageSize(Object key) {
1245 if (validateIfNecessary()) {
1246 int size = getIntAttr(getAttributes(), key, -1);
1247
1248 if (size == -1) {
1249 View v = getView();
1250
1251 size = 0;
1252 if (v instanceof ImageView) {
1253 Image img = ((ImageView)v).getImage();
1254 if (img != null) {
1255 if (key == HTML.Attribute.WIDTH) {
1256 size = img.getWidth(null);
1257 }
1258 else {
1259 size = img.getHeight(null);
1260 }
1261 }
1262 }
1263 }
1264 return size;
1265 }
1266 return 0;
1267 }
1268
1269 // begin AccessibleIcon implementation ...
1270 private AccessibleContext accessibleContext;
1271
1272 public AccessibleContext getAccessibleContext() {
1273 if (accessibleContext == null) {
1274 accessibleContext = new IconAccessibleContext(this);
1275 }
1276 return accessibleContext;
1277 }
1278
1279 /*
1280 * AccessibleContext for images
1281 */
1282 protected class IconAccessibleContext extends HTMLAccessibleContext
1283 implements AccessibleIcon {
1284
1285 public IconAccessibleContext(ElementInfo elementInfo) {
1286 super(elementInfo);
1287 }
1288
1289 /**
1290 * Gets the accessibleName property of this object. The accessibleName
1291 * property of an object is a localized String that designates the purpose
1292 * of the object. For example, the accessibleName property of a label
1293 * or button might be the text of the label or button itself. In the
1294 * case of an object that doesn't display its name, the accessibleName
1295 * should still be set. For example, in the case of a text field used
1296 * to enter the name of a city, the accessibleName for the en_US locale
1297 * could be 'city.'
1298 *
1299 * @return the localized name of the object; null if this
1300 * object does not have a name
1301 *
1302 * @see #setAccessibleName
1303 */
1304 public String getAccessibleName() {
1305 return getAccessibleIconDescription();
1306 }
1307
1308 /**
1309 * Gets the accessibleDescription property of this object. If this
1310 * property isn't set, returns the content type of this
1311 * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text").
1312 *
1313 * @return the localized description of the object; <code>null</code>
1314 * if this object does not have a description
1315 *
1316 * @see #setAccessibleName
1317 */
1318 public String getAccessibleDescription() {
1319 return editor.getContentType();
1320 }
1321
1322 /**
1323 * Gets the role of this object. The role of the object is the generic
1324 * purpose or use of the class of this object. For example, the role
1325 * of a push button is AccessibleRole.PUSH_BUTTON. The roles in
1326 * AccessibleRole are provided so component developers can pick from
1327 * a set of predefined roles. This enables assistive technologies to
1328 * provide a consistent interface to various tweaked subclasses of
1329 * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
1330 * that act like a push button) as well as distinguish between sublasses
1331 * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
1332 * and AccessibleRole.RADIO_BUTTON for radio buttons).
1333 * <p>Note that the AccessibleRole class is also extensible, so
1334 * custom component developers can define their own AccessibleRole's
1335 * if the set of predefined roles is inadequate.
1336 *
1337 * @return an instance of AccessibleRole describing the role of the object
1338 * @see AccessibleRole
1339 */
1340 public AccessibleRole getAccessibleRole() {
1341 return AccessibleRole.ICON;
1342 }
1343
1344 public AccessibleIcon [] getAccessibleIcon() {
1345 AccessibleIcon [] icons = new AccessibleIcon[1];
1346 icons[0] = this;
1347 return icons;
1348 }
1349
1350 /**
1351 * Gets the description of the icon. This is meant to be a brief
1352 * textual description of the object. For example, it might be
1353 * presented to a blind user to give an indication of the purpose
1354 * of the icon.
1355 *
1356 * @return the description of the icon
1357 */
1358 public String getAccessibleIconDescription() {
1359 return ((ImageView)getView()).getAltText();
1360 }
1361
1362 /**
1363 * Sets the description of the icon. This is meant to be a brief
1364 * textual description of the object. For example, it might be
1365 * presented to a blind user to give an indication of the purpose
1366 * of the icon.
1367 *
1368 * @param description the description of the icon
1369 */
1370 public void setAccessibleIconDescription(String description) {
1371 }
1372
1373 /**
1374 * Gets the width of the icon
1375 *
1376 * @return the width of the icon.
1377 */
1378 public int getAccessibleIconWidth() {
1379 if (width == -1) {
1380 width = getImageSize(HTML.Attribute.WIDTH);
1381 }
1382 return width;
1383 }
1384
1385 /**
1386 * Gets the height of the icon
1387 *
1388 * @return the height of the icon.
1389 */
1390 public int getAccessibleIconHeight() {
1391 if (height == -1) {
1392 height = getImageSize(HTML.Attribute.HEIGHT);
1393 }
1394 return height;
1395 }
1396 }
1397 // ... end AccessibleIconImplementation
1398 }
1399
1400
1401 /**
1402 * TableElementInfo encapsulates information about a HTML.Tag.TABLE.
1403 * To make access fast it crates a grid containing the children to
1404 * allow for access by row, column. TableElementInfo will contain
1405 * TableRowElementInfos, which will contain TableCellElementInfos.
1406 * Any time one of the rows or columns becomes invalid the table is
1407 * invalidated. This is because any time one of the child attributes
1408 * changes the size of the grid may have changed.
1409 */
1410 private class TableElementInfo extends ElementInfo
1411 implements Accessible {
1412
1413 protected ElementInfo caption;
1414
1415 /**
1416 * Allocation of the table by row x column. There may be holes (eg
1417 * nulls) depending upon the html, any cell that has a rowspan/colspan
1418 * > 1 will be contained multiple times in the grid.
1419 */
1420 private TableCellElementInfo[][] grid;
1421
1422
1423 TableElementInfo(Element e, ElementInfo parent) {
1424 super(e, parent);
1425 }
1426
1427 public ElementInfo getCaptionInfo() {
1428 return caption;
1429 }
1430
1431 /**
1432 * Overriden to update the grid when validating.
1433 */
1434 protected void validate() {
1435 super.validate();
1436 updateGrid();
1437 }
1438
1439 /**
1440 * Overriden to only alloc instances of TableRowElementInfos.
1441 */
1442 protected void loadChildren(Element e) {
1443
1444 for (int counter = 0; counter < e.getElementCount(); counter++) {
1445 Element child = e.getElement(counter);
1446 AttributeSet attrs = child.getAttributes();
1447
1448 if (attrs.getAttribute(StyleConstants.NameAttribute) ==
1449 HTML.Tag.TR) {
1450 addChild(new TableRowElementInfo(child, this, counter));
1451
1452 } else if (attrs.getAttribute(StyleConstants.NameAttribute) ==
1453 HTML.Tag.CAPTION) {
1454 // Handle captions as a special case since all other
1455 // children are table rows.
1456 caption = createElementInfo(child, this);
1457 }
1458 }
1459 }
1460
1461 /**
1462 * Updates the grid.
1463 */
1464 private void updateGrid() {
1465 // Determine the max row/col count.
1466 int delta = 0;
1467 int maxCols = 0;
1468 int rows;
1469 for (int counter = 0; counter < getChildCount(); counter++) {
1470 TableRowElementInfo row = getRow(counter);
1471 int prev = 0;
1472 for (int y = 0; y < delta; y++) {
1473 prev = Math.max(prev, getRow(counter - y - 1).
1474 getColumnCount(y + 2));
1475 }
1476 delta = Math.max(row.getRowCount(), delta);
1477 delta--;
1478 maxCols = Math.max(maxCols, row.getColumnCount() + prev);
1479 }
1480 rows = getChildCount() + delta;
1481
1482 // Alloc
1483 grid = new TableCellElementInfo[rows][];
1484 for (int counter = 0; counter < rows; counter++) {
1485 grid[counter] = new TableCellElementInfo[maxCols];
1486 }
1487 // Update
1488 for (int counter = 0; counter < rows; counter++) {
1489 getRow(counter).updateGrid(counter);
1490 }
1491 }
1492
1493 /**
1494 * Returns the TableCellElementInfo at the specified index.
1495 */
1496 public TableRowElementInfo getRow(int index) {
1497 return (TableRowElementInfo)getChild(index);
1498 }
1499
1500 /**
1501 * Returns the TableCellElementInfo by row and column.
1502 */
1503 public TableCellElementInfo getCell(int r, int c) {
1504 if (validateIfNecessary() && r < grid.length &&
1505 c < grid[0].length) {
1506 return grid[r][c];
1507 }
1508 return null;
1509 }
1510
1511 /**
1512 * Returns the rowspan of the specified entry.
1513 */
1514 public int getRowExtentAt(int r, int c) {
1515 TableCellElementInfo cell = getCell(r, c);
1516
1517 if (cell != null) {
1518 int rows = cell.getRowCount();
1519 int delta = 1;
1520
1521 while ((r - delta) >= 0 && grid[r - delta][c] == cell) {
1522 delta++;
1523 }
1524 return rows - delta + 1;
1525 }
1526 return 0;
1527 }
1528
1529 /**
1530 * Returns the colspan of the specified entry.
1531 */
1532 public int getColumnExtentAt(int r, int c) {
1533 TableCellElementInfo cell = getCell(r, c);
1534
1535 if (cell != null) {
1536 int cols = cell.getColumnCount();
1537 int delta = 1;
1538
1539 while ((c - delta) >= 0 && grid[r][c - delta] == cell) {
1540 delta++;
1541 }
1542 return cols - delta + 1;
1543 }
1544 return 0;
1545 }
1546
1547 /**
1548 * Returns the number of rows in the table.
1549 */
1550 public int getRowCount() {
1551 if (validateIfNecessary()) {
1552 return grid.length;
1553 }
1554 return 0;
1555 }
1556
1557 /**
1558 * Returns the number of columns in the table.
1559 */
1560 public int getColumnCount() {
1561 if (validateIfNecessary() && grid.length > 0) {
1562 return grid[0].length;
1563 }
1564 return 0;
1565 }
1566
1567 // begin AccessibleTable implementation ...
1568 private AccessibleContext accessibleContext;
1569
1570 public AccessibleContext getAccessibleContext() {
1571 if (accessibleContext == null) {
1572 accessibleContext = new TableAccessibleContext(this);
1573 }
1574 return accessibleContext;
1575 }
1576
1577 /*
1578 * AccessibleContext for tables
1579 */
1580 public class TableAccessibleContext extends HTMLAccessibleContext
1581 implements AccessibleTable {
1582
1583 private AccessibleHeadersTable rowHeadersTable;
1584
1585 public TableAccessibleContext(ElementInfo elementInfo) {
1586 super(elementInfo);
1587 }
1588
1589 /**
1590 * Gets the accessibleName property of this object. The accessibleName
1591 * property of an object is a localized String that designates the purpose
1592 * of the object. For example, the accessibleName property of a label
1593 * or button might be the text of the label or button itself. In the
1594 * case of an object that doesn't display its name, the accessibleName
1595 * should still be set. For example, in the case of a text field used
1596 * to enter the name of a city, the accessibleName for the en_US locale
1597 * could be 'city.'
1598 *
1599 * @return the localized name of the object; null if this
1600 * object does not have a name
1601 *
1602 * @see #setAccessibleName
1603 */
1604 public String getAccessibleName() {
1605 // return the role of the object
1606 return getAccessibleRole().toString();
1607 }
1608
1609 /**
1610 * Gets the accessibleDescription property of this object. If this
1611 * property isn't set, returns the content type of this
1612 * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text").
1613 *
1614 * @return the localized description of the object; <code>null</code>
1615 * if this object does not have a description
1616 *
1617 * @see #setAccessibleName
1618 */
1619 public String getAccessibleDescription() {
1620 return editor.getContentType();
1621 }
1622
1623 /**
1624 * Gets the role of this object. The role of the object is the generic
1625 * purpose or use of the class of this object. For example, the role
1626 * of a push button is AccessibleRole.PUSH_BUTTON. The roles in
1627 * AccessibleRole are provided so component developers can pick from
1628 * a set of predefined roles. This enables assistive technologies to
1629 * provide a consistent interface to various tweaked subclasses of
1630 * components (e.g., use AccessibleRole.PUSH_BUTTON for all components
1631 * that act like a push button) as well as distinguish between sublasses
1632 * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes
1633 * and AccessibleRole.RADIO_BUTTON for radio buttons).
1634 * <p>Note that the AccessibleRole class is also extensible, so
1635 * custom component developers can define their own AccessibleRole's
1636 * if the set of predefined roles is inadequate.
1637 *
1638 * @return an instance of AccessibleRole describing the role of the object
1639 * @see AccessibleRole
1640 */
1641 public AccessibleRole getAccessibleRole() {
1642 return AccessibleRole.TABLE;
1643 }
1644
1645 /**
1646 * Gets the 0-based index of this object in its accessible parent.
1647 *
1648 * @return the 0-based index of this object in its parent; -1 if this
1649 * object does not have an accessible parent.
1650 *
1651 * @see #getAccessibleParent
1652 * @see #getAccessibleChildrenCount
1653 * @gsee #getAccessibleChild
1654 */
1655 public int getAccessibleIndexInParent() {
1656 return elementInfo.getIndexInParent();
1657 }
1658
1659 /**
1660 * Returns the number of accessible children of the object.
1661 *
1662 * @return the number of accessible children of the object.
1663 */
1664 public int getAccessibleChildrenCount() {
1665 return ((TableElementInfo)elementInfo).getRowCount() *
1666 ((TableElementInfo)elementInfo).getColumnCount();
1667 }
1668
1669 /**
1670 * Returns the specified Accessible child of the object. The Accessible
1671 * children of an Accessible object are zero-based, so the first child
1672 * of an Accessible child is at index 0, the second child is at index 1,
1673 * and so on.
1674 *
1675 * @param i zero-based index of child
1676 * @return the Accessible child of the object
1677 * @see #getAccessibleChildrenCount
1678 */
1679 public Accessible getAccessibleChild(int i) {
1680 int rowCount = ((TableElementInfo)elementInfo).getRowCount();
1681 int columnCount = ((TableElementInfo)elementInfo).getColumnCount();
1682 int r = i / rowCount;
1683 int c = i % columnCount;
1684 if (r < 0 || r >= rowCount || c < 0 || c >= columnCount) {
1685 return null;
1686 } else {
1687 return getAccessibleAt(r, c);
1688 }
1689 }
1690
1691 public AccessibleTable getAccessibleTable() {
1692 return this;
1693 }
1694
1695 /**
1696 * Returns the caption for the table.
1697 *
1698 * @return the caption for the table
1699 */
1700 public Accessible getAccessibleCaption() {
1701 ElementInfo captionInfo = getCaptionInfo();
1702 if (captionInfo instanceof Accessible) {
1703 return (Accessible)caption;
1704 } else {
1705 return null;
1706 }
1707 }
1708
1709 /**
1710 * Sets the caption for the table.
1711 *
1712 * @param a the caption for the table
1713 */
1714 public void setAccessibleCaption(Accessible a) {
1715 }
1716
1717 /**
1718 * Returns the summary description of the table.
1719 *
1720 * @return the summary description of the table
1721 */
1722 public Accessible getAccessibleSummary() {
1723 return null;
1724 }
1725
1726 /**
1727 * Sets the summary description of the table
1728 *
1729 * @param a the summary description of the table
1730 */
1731 public void setAccessibleSummary(Accessible a) {
1732 }
1733
1734 /**
1735 * Returns the number of rows in the table.
1736 *
1737 * @return the number of rows in the table
1738 */
1739 public int getAccessibleRowCount() {
1740 return ((TableElementInfo)elementInfo).getRowCount();
1741 }
1742
1743 /**
1744 * Returns the number of columns in the table.
1745 *
1746 * @return the number of columns in the table
1747 */
1748 public int getAccessibleColumnCount() {
1749 return ((TableElementInfo)elementInfo).getColumnCount();
1750 }
1751
1752 /**
1753 * Returns the Accessible at a specified row and column
1754 * in the table.
1755 *
1756 * @param r zero-based row of the table
1757 * @param c zero-based column of the table
1758 * @return the Accessible at the specified row and column
1759 */
1760 public Accessible getAccessibleAt(int r, int c) {
1761 TableCellElementInfo cellInfo = getCell(r, c);
1762 if (cellInfo != null) {
1763 return cellInfo.getAccessible();
1764 } else {
1765 return null;
1766 }
1767 }
1768
1769 /**
1770 * Returns the number of rows occupied by the Accessible at
1771 * a specified row and column in the table.
1772 *
1773 * @return the number of rows occupied by the Accessible at a
1774 * given specified (row, column)
1775 */
1776 public int getAccessibleRowExtentAt(int r, int c) {
1777 return ((TableElementInfo)elementInfo).getRowExtentAt(r, c);
1778 }
1779
1780 /**
1781 * Returns the number of columns occupied by the Accessible at
1782 * a specified row and column in the table.
1783 *
1784 * @return the number of columns occupied by the Accessible at a
1785 * given specified row and column
1786 */
1787 public int getAccessibleColumnExtentAt(int r, int c) {
1788 return ((TableElementInfo)elementInfo).getColumnExtentAt(r, c);
1789 }
1790
1791 /**
1792 * Returns the row headers as an AccessibleTable.
1793 *
1794 * @return an AccessibleTable representing the row
1795 * headers
1796 */
1797 public AccessibleTable getAccessibleRowHeader() {
1798 return rowHeadersTable;
1799 }
1800
1801 /**
1802 * Sets the row headers.
1803 *
1804 * @param table an AccessibleTable representing the
1805 * row headers
1806 */
1807 public void setAccessibleRowHeader(AccessibleTable table) {
1808 }
1809
1810 /**
1811 * Returns the column headers as an AccessibleTable.
1812 *
1813 * @return an AccessibleTable representing the column
1814 * headers
1815 */
1816 public AccessibleTable getAccessibleColumnHeader() {
1817 return null;
1818 }
1819
1820 /**
1821 * Sets the column headers.
1822 *
1823 * @param table an AccessibleTable representing the
1824 * column headers
1825 */
1826 public void setAccessibleColumnHeader(AccessibleTable table) {
1827 }
1828
1829 /**
1830 * Returns the description of the specified row in the table.
1831 *
1832 * @param r zero-based row of the table
1833 * @return the description of the row
1834 */
1835 public Accessible getAccessibleRowDescription(int r) {
1836 return null;
1837 }
1838
1839 /**
1840 * Sets the description text of the specified row of the table.
1841 *
1842 * @param r zero-based row of the table
1843 * @param a the description of the row
1844 */
1845 public void setAccessibleRowDescription(int r, Accessible a) {
1846 }
1847
1848 /**
1849 * Returns the description text of the specified column in the table.
1850 *
1851 * @param c zero-based column of the table
1852 * @return the text description of the column
1853 */
1854 public Accessible getAccessibleColumnDescription(int c) {
1855 return null;
1856 }
1857
1858 /**
1859 * Sets the description text of the specified column in the table.
1860 *
1861 * @param c zero-based column of the table
1862 * @param a the text description of the column
1863 */
1864 public void setAccessibleColumnDescription(int c, Accessible a) {
1865 }
1866
1867 /**
1868 * Returns a boolean value indicating whether the accessible at
1869 * a specified row and column is selected.
1870 *
1871 * @param r zero-based row of the table
1872 * @param c zero-based column of the table
1873 * @return the boolean value true if the accessible at the
1874 * row and column is selected. Otherwise, the boolean value
1875 * false
1876 */
1877 public boolean isAccessibleSelected(int r, int c) {
1878 if (validateIfNecessary()) {
1879 if (r < 0 || r >= getAccessibleRowCount() ||
1880 c < 0 || c >= getAccessibleColumnCount()) {
1881 return false;
1882 }
1883 TableCellElementInfo cell = getCell(r, c);
1884 if (cell != null) {
1885 Element elem = cell.getElement();
1886 int start = elem.getStartOffset();
1887 int end = elem.getEndOffset();
1888 return start >= editor.getSelectionStart() &&
1889 end <= editor.getSelectionEnd();
1890 }
1891 }
1892 return false;
1893 }
1894
1895 /**
1896 * Returns a boolean value indicating whether the specified row
1897 * is selected.
1898 *
1899 * @param r zero-based row of the table
1900 * @return the boolean value true if the specified row is selected.
1901 * Otherwise, false.
1902 */
1903 public boolean isAccessibleRowSelected(int r) {
1904 if (validateIfNecessary()) {
1905 if (r < 0 || r >= getAccessibleRowCount()) {
1906 return false;
1907 }
1908 int nColumns = getAccessibleColumnCount();
1909
1910 TableCellElementInfo startCell = getCell(r, 0);
1911 if (startCell == null) {
1912 return false;
1913 }
1914 int start = startCell.getElement().getStartOffset();
1915
1916 TableCellElementInfo endCell = getCell(r, nColumns-1);
1917 if (endCell == null) {
1918 return false;
1919 }
1920 int end = endCell.getElement().getEndOffset();
1921
1922 return start >= editor.getSelectionStart() &&
1923 end <= editor.getSelectionEnd();
1924 }
1925 return false;
1926 }
1927
1928 /**
1929 * Returns a boolean value indicating whether the specified column
1930 * is selected.
1931 *
1932 * @param c zero-based column of the table
1933 * @return the boolean value true if the specified column is selected.
1934 * Otherwise, false.
1935 */
1936 public boolean isAccessibleColumnSelected(int c) {
1937 if (validateIfNecessary()) {
1938 if (c < 0 || c >= getAccessibleColumnCount()) {
1939 return false;
1940 }
1941 int nRows = getAccessibleRowCount();
1942
1943 TableCellElementInfo startCell = getCell(0, c);
1944 if (startCell == null) {
1945 return false;
1946 }
1947 int start = startCell.getElement().getStartOffset();
1948
1949 TableCellElementInfo endCell = getCell(nRows-1, c);
1950 if (endCell == null) {
1951 return false;
1952 }
1953 int end = endCell.getElement().getEndOffset();
1954 return start >= editor.getSelectionStart() &&
1955 end <= editor.getSelectionEnd();
1956 }
1957 return false;
1958 }
1959
1960 /**
1961 * Returns the selected rows in a table.
1962 *
1963 * @return an array of selected rows where each element is a
1964 * zero-based row of the table
1965 */
1966 public int [] getSelectedAccessibleRows() {
1967 if (validateIfNecessary()) {
1968 int nRows = getAccessibleRowCount();
1969 Vector<Integer> vec = new Vector<Integer>();
1970
1971 for (int i = 0; i < nRows; i++) {
1972 if (isAccessibleRowSelected(i)) {
1973 vec.addElement(Integer.valueOf(i));
1974 }
1975 }
1976 int retval[] = new int[vec.size()];
1977 for (int i = 0; i < retval.length; i++) {
1978 retval[i] = vec.elementAt(i).intValue();
1979 }
1980 return retval;
1981 }
1982 return new int[0];
1983 }
1984
1985 /**
1986 * Returns the selected columns in a table.
1987 *
1988 * @return an array of selected columns where each element is a
1989 * zero-based column of the table
1990 */
1991 public int [] getSelectedAccessibleColumns() {
1992 if (validateIfNecessary()) {
1993 int nColumns = getAccessibleRowCount();
1994 Vector<Integer> vec = new Vector<Integer>();
1995
1996 for (int i = 0; i < nColumns; i++) {
1997 if (isAccessibleColumnSelected(i)) {
1998 vec.addElement(Integer.valueOf(i));
1999 }
2000 }
2001 int retval[] = new int[vec.size()];
2002 for (int i = 0; i < retval.length; i++) {
2003 retval[i] = vec.elementAt(i).intValue();
2004 }
2005 return retval;
2006 }
2007 return new int[0];
2008 }
2009
2010 // begin AccessibleExtendedTable implementation -------------
2011
2012 /**
2013 * Returns the row number of an index in the table.
2014 *
2015 * @param index the zero-based index in the table
2016 * @return the zero-based row of the table if one exists;
2017 * otherwise -1.
2018 */
2019 public int getAccessibleRow(int index) {
2020 if (validateIfNecessary()) {
2021 int numCells = getAccessibleColumnCount() *
2022 getAccessibleRowCount();
2023 if (index >= numCells) {
2024 return -1;
2025 } else {
2026 return index / getAccessibleColumnCount();
2027 }
2028 }
2029 return -1;
2030 }
2031
2032 /**
2033 * Returns the column number of an index in the table.
2034 *
2035 * @param index the zero-based index in the table
2036 * @return the zero-based column of the table if one exists;
2037 * otherwise -1.
2038 */
2039 public int getAccessibleColumn(int index) {
2040 if (validateIfNecessary()) {
2041 int numCells = getAccessibleColumnCount() *
2042 getAccessibleRowCount();
2043 if (index >= numCells) {
2044 return -1;
2045 } else {
2046 return index % getAccessibleColumnCount();
2047 }
2048 }
2049 return -1;
2050 }
2051
2052 /**
2053 * Returns the index at a row and column in the table.
2054 *
2055 * @param r zero-based row of the table
2056 * @param c zero-based column of the table
2057 * @return the zero-based index in the table if one exists;
2058 * otherwise -1.
2059 */
2060 public int getAccessibleIndex(int r, int c) {
2061 if (validateIfNecessary()) {
2062 if (r >= getAccessibleRowCount() ||
2063 c >= getAccessibleColumnCount()) {
2064 return -1;
2065 } else {
2066 return r * getAccessibleColumnCount() + c;
2067 }
2068 }
2069 return -1;
2070 }
2071
2072 /**
2073 * Returns the row header at a row in a table.
2074 * @param r zero-based row of the table
2075 *
2076 * @return a String representing the row header
2077 * if one exists; otherwise null.
2078 */
2079 public String getAccessibleRowHeader(int r) {
2080 if (validateIfNecessary()) {
2081 TableCellElementInfo cellInfo = getCell(r, 0);
2082 if (cellInfo.isHeaderCell()) {
2083 View v = cellInfo.getView();
2084 if (v != null && model != null) {
2085 try {
2086 return model.getText(v.getStartOffset(),
2087 v.getEndOffset() -
2088 v.getStartOffset());
2089 } catch (BadLocationException e) {
2090 return null;
2091 }
2092 }
2093 }
2094 }
2095 return null;
2096 }
2097
2098 /**
2099 * Returns the column header at a column in a table.
2100 * @param c zero-based column of the table
2101 *
2102 * @return a String representing the column header
2103 * if one exists; otherwise null.
2104 */
2105 public String getAccessibleColumnHeader(int c) {
2106 if (validateIfNecessary()) {
2107 TableCellElementInfo cellInfo = getCell(0, c);
2108 if (cellInfo.isHeaderCell()) {
2109 View v = cellInfo.getView();
2110 if (v != null && model != null) {
2111 try {
2112 return model.getText(v.getStartOffset(),
2113 v.getEndOffset() -
2114 v.getStartOffset());
2115 } catch (BadLocationException e) {
2116 return null;
2117 }
2118 }
2119 }
2120 }
2121 return null;
2122 }
2123
2124 public void addRowHeader(TableCellElementInfo cellInfo, int rowNumber) {
2125 if (rowHeadersTable == null) {
2126 rowHeadersTable = new AccessibleHeadersTable();
2127 }
2128 rowHeadersTable.addHeader(cellInfo, rowNumber);
2129 }
2130 // end of AccessibleExtendedTable implementation ------------
2131
2132 protected class AccessibleHeadersTable implements AccessibleTable {
2133
2134 // Header information is modeled as a Hashtable of
2135 // ArrayLists where each Hashtable entry represents
2136 // a row containing one or more headers.
2137 private Hashtable<Integer, ArrayList<TableCellElementInfo>> headers =
2138 new Hashtable<Integer, ArrayList<TableCellElementInfo>>();
2139 private int rowCount = 0;
2140 private int columnCount = 0;
2141
2142 public void addHeader(TableCellElementInfo cellInfo, int rowNumber) {
2143 Integer rowInteger = Integer.valueOf(rowNumber);
2144 ArrayList<TableCellElementInfo> list = headers.get(rowInteger);
2145 if (list == null) {
2146 list = new ArrayList<TableCellElementInfo>();
2147 headers.put(rowInteger, list);
2148 }
2149 list.add(cellInfo);
2150 }
2151
2152 /**
2153 * Returns the caption for the table.
2154 *
2155 * @return the caption for the table
2156 */
2157 public Accessible getAccessibleCaption() {
2158 return null;
2159 }
2160
2161 /**
2162 * Sets the caption for the table.
2163 *
2164 * @param a the caption for the table
2165 */
2166 public void setAccessibleCaption(Accessible a) {
2167 }
2168
2169 /**
2170 * Returns the summary description of the table.
2171 *
2172 * @return the summary description of the table
2173 */
2174 public Accessible getAccessibleSummary() {
2175 return null;
2176 }
2177
2178 /**
2179 * Sets the summary description of the table
2180 *
2181 * @param a the summary description of the table
2182 */
2183 public void setAccessibleSummary(Accessible a) {
2184 }
2185
2186 /**
2187 * Returns the number of rows in the table.
2188 *
2189 * @return the number of rows in the table
2190 */
2191 public int getAccessibleRowCount() {
2192 return rowCount;
2193 }
2194
2195 /**
2196 * Returns the number of columns in the table.
2197 *
2198 * @return the number of columns in the table
2199 */
2200 public int getAccessibleColumnCount() {
2201 return columnCount;
2202 }
2203
2204 private TableCellElementInfo getElementInfoAt(int r, int c) {
2205 ArrayList<TableCellElementInfo> list = headers.get(Integer.valueOf(r));
2206 if (list != null) {
2207 return list.get(c);
2208 } else {
2209 return null;
2210 }
2211 }
2212
2213 /**
2214 * Returns the Accessible at a specified row and column
2215 * in the table.
2216 *
2217 * @param r zero-based row of the table
2218 * @param c zero-based column of the table
2219 * @return the Accessible at the specified row and column
2220 */
2221 public Accessible getAccessibleAt(int r, int c) {
2222 ElementInfo elementInfo = getElementInfoAt(r, c);
2223 if (elementInfo instanceof Accessible) {
2224 return (Accessible)elementInfo;
2225 } else {
2226 return null;
2227 }
2228 }
2229
2230 /**
2231 * Returns the number of rows occupied by the Accessible at
2232 * a specified row and column in the table.
2233 *
2234 * @return the number of rows occupied by the Accessible at a
2235 * given specified (row, column)
2236 */
2237 public int getAccessibleRowExtentAt(int r, int c) {
2238 TableCellElementInfo elementInfo = getElementInfoAt(r, c);
2239 if (elementInfo != null) {
2240 return elementInfo.getRowCount();
2241 } else {
2242 return 0;
2243 }
2244 }
2245
2246 /**
2247 * Returns the number of columns occupied by the Accessible at
2248 * a specified row and column in the table.
2249 *
2250 * @return the number of columns occupied by the Accessible at a
2251 * given specified row and column
2252 */
2253 public int getAccessibleColumnExtentAt(int r, int c) {
2254 TableCellElementInfo elementInfo = getElementInfoAt(r, c);
2255 if (elementInfo != null) {
2256 return elementInfo.getRowCount();
2257 } else {
2258 return 0;
2259 }
2260 }
2261
2262 /**
2263 * Returns the row headers as an AccessibleTable.
2264 *
2265 * @return an AccessibleTable representing the row
2266 * headers
2267 */
2268 public AccessibleTable getAccessibleRowHeader() {
2269 return null;
2270 }
2271
2272 /**
2273 * Sets the row headers.
2274 *
2275 * @param table an AccessibleTable representing the
2276 * row headers
2277 */
2278 public void setAccessibleRowHeader(AccessibleTable table) {
2279 }
2280
2281 /**
2282 * Returns the column headers as an AccessibleTable.
2283 *
2284 * @return an AccessibleTable representing the column
2285 * headers
2286 */
2287 public AccessibleTable getAccessibleColumnHeader() {
2288 return null;
2289 }
2290
2291 /**
2292 * Sets the column headers.
2293 *
2294 * @param table an AccessibleTable representing the
2295 * column headers
2296 */
2297 public void setAccessibleColumnHeader(AccessibleTable table) {
2298 }
2299
2300 /**
2301 * Returns the description of the specified row in the table.
2302 *
2303 * @param r zero-based row of the table
2304 * @return the description of the row
2305 */
2306 public Accessible getAccessibleRowDescription(int r) {
2307 return null;
2308 }
2309
2310 /**
2311 * Sets the description text of the specified row of the table.
2312 *
2313 * @param r zero-based row of the table
2314 * @param a the description of the row
2315 */
2316 public void setAccessibleRowDescription(int r, Accessible a) {
2317 }
2318
2319 /**
2320 * Returns the description text of the specified column in the table.
2321 *
2322 * @param c zero-based column of the table
2323 * @return the text description of the column
2324 */
2325 public Accessible getAccessibleColumnDescription(int c) {
2326 return null;
2327 }
2328
2329 /**
2330 * Sets the description text of the specified column in the table.
2331 *
2332 * @param c zero-based column of the table
2333 * @param a the text description of the column
2334 */
2335 public void setAccessibleColumnDescription(int c, Accessible a) {
2336 }
2337
2338 /**
2339 * Returns a boolean value indicating whether the accessible at
2340 * a specified row and column is selected.
2341 *
2342 * @param r zero-based row of the table
2343 * @param c zero-based column of the table
2344 * @return the boolean value true if the accessible at the
2345 * row and column is selected. Otherwise, the boolean value
2346 * false
2347 */
2348 public boolean isAccessibleSelected(int r, int c) {
2349 return false;
2350 }
2351
2352 /**
2353 * Returns a boolean value indicating whether the specified row
2354 * is selected.
2355 *
2356 * @param r zero-based row of the table
2357 * @return the boolean value true if the specified row is selected.
2358 * Otherwise, false.
2359 */
2360 public boolean isAccessibleRowSelected(int r) {
2361 return false;
2362 }
2363
2364 /**
2365 * Returns a boolean value indicating whether the specified column
2366 * is selected.
2367 *
2368 * @param c zero-based column of the table
2369 * @return the boolean value true if the specified column is selected.
2370 * Otherwise, false.
2371 */
2372 public boolean isAccessibleColumnSelected(int c) {
2373 return false;
2374 }
2375
2376 /**
2377 * Returns the selected rows in a table.
2378 *
2379 * @return an array of selected rows where each element is a
2380 * zero-based row of the table
2381 */
2382 public int [] getSelectedAccessibleRows() {
2383 return new int [0];
2384 }
2385
2386 /**
2387 * Returns the selected columns in a table.
2388 *
2389 * @return an array of selected columns where each element is a
2390 * zero-based column of the table
2391 */
2392 public int [] getSelectedAccessibleColumns() {
2393 return new int [0];
2394 }
2395 }
2396 } // ... end AccessibleHeadersTable
2397
2398 /*
2399 * ElementInfo for table rows
2400 */
2401 private class TableRowElementInfo extends ElementInfo {
2402
2403 private TableElementInfo parent;
2404 private int rowNumber;
2405
2406 TableRowElementInfo(Element e, TableElementInfo parent, int rowNumber) {
2407 super(e, parent);
2408 this.parent = parent;
2409 this.rowNumber = rowNumber;
2410 }
2411
2412 protected void loadChildren(Element e) {
2413 for (int x = 0; x < e.getElementCount(); x++) {
2414 AttributeSet attrs = e.getElement(x).getAttributes();
2415
2416 if (attrs.getAttribute(StyleConstants.NameAttribute) ==
2417 HTML.Tag.TH) {
2418 TableCellElementInfo headerElementInfo =
2419 new TableCellElementInfo(e.getElement(x), this, true);
2420 addChild(headerElementInfo);
2421
2422 AccessibleTable at =
2423 parent.getAccessibleContext().getAccessibleTable();
2424 TableAccessibleContext tableElement =
2425 (TableAccessibleContext)at;
2426 tableElement.addRowHeader(headerElementInfo, rowNumber);
2427
2428 } else if (attrs.getAttribute(StyleConstants.NameAttribute) ==
2429 HTML.Tag.TD) {
2430 addChild(new TableCellElementInfo(e.getElement(x), this,
2431 false));
2432 }
2433 }
2434 }
2435
2436 /**
2437 * Returns the max of the rowspans of the cells in this row.
2438 */
2439 public int getRowCount() {
2440 int rowCount = 1;
2441 if (validateIfNecessary()) {
2442 for (int counter = 0; counter < getChildCount();
2443 counter++) {
2444
2445 TableCellElementInfo cell = (TableCellElementInfo)
2446 getChild(counter);
2447
2448 if (cell.validateIfNecessary()) {
2449 rowCount = Math.max(rowCount, cell.getRowCount());
2450 }
2451 }
2452 }
2453 return rowCount;
2454 }
2455
2456 /**
2457 * Returns the sum of the column spans of the individual
2458 * cells in this row.
2459 */
2460 public int getColumnCount() {
2461 int colCount = 0;
2462 if (validateIfNecessary()) {
2463 for (int counter = 0; counter < getChildCount();
2464 counter++) {
2465 TableCellElementInfo cell = (TableCellElementInfo)
2466 getChild(counter);
2467
2468 if (cell.validateIfNecessary()) {
2469 colCount += cell.getColumnCount();
2470 }
2471 }
2472 }
2473 return colCount;
2474 }
2475
2476 /**
2477 * Overriden to invalidate the table as well as
2478 * TableRowElementInfo.
2479 */
2480 protected void invalidate(boolean first) {
2481 super.invalidate(first);
2482 getParent().invalidate(true);
2483 }
2484
2485 /**
2486 * Places the TableCellElementInfos for this element in
2487 * the grid.
2488 */
2489 private void updateGrid(int row) {
2490 if (validateIfNecessary()) {
2491 boolean emptyRow = false;
2492
2493 while (!emptyRow) {
2494 for (int counter = 0; counter < grid[row].length;
2495 counter++) {
2496 if (grid[row][counter] == null) {
2497 emptyRow = true;
2498 break;
2499 }
2500 }
2501 if (!emptyRow) {
2502 row++;
2503 }
2504 }
2505 for (int col = 0, counter = 0; counter < getChildCount();
2506 counter++) {
2507 TableCellElementInfo cell = (TableCellElementInfo)
2508 getChild(counter);
2509
2510 while (grid[row][col] != null) {
2511 col++;
2512 }
2513 for (int rowCount = cell.getRowCount() - 1;
2514 rowCount >= 0; rowCount--) {
2515 for (int colCount = cell.getColumnCount() - 1;
2516 colCount >= 0; colCount--) {
2517 grid[row + rowCount][col + colCount] = cell;
2518 }
2519 }
2520 col += cell.getColumnCount();
2521 }
2522 }
2523 }
2524
2525 /**
2526 * Returns the column count of the number of columns that have
2527 * a rowcount >= rowspan.
2528 */
2529 private int getColumnCount(int rowspan) {
2530 if (validateIfNecessary()) {
2531 int cols = 0;
2532 for (int counter = 0; counter < getChildCount();
2533 counter++) {
2534 TableCellElementInfo cell = (TableCellElementInfo)
2535 getChild(counter);
2536
2537 if (cell.getRowCount() >= rowspan) {
2538 cols += cell.getColumnCount();
2539 }
2540 }
2541 return cols;
2542 }
2543 return 0;
2544 }
2545 }
2546
2547 /**
2548 * TableCellElementInfo is used to represents the cells of
2549 * the table.
2550 */
2551 private class TableCellElementInfo extends ElementInfo {
2552
2553 private Accessible accessible;
2554 private boolean isHeaderCell;
2555
2556 TableCellElementInfo(Element e, ElementInfo parent) {
2557 super(e, parent);
2558 this.isHeaderCell = false;
2559 }
2560
2561 TableCellElementInfo(Element e, ElementInfo parent,
2562 boolean isHeaderCell) {
2563 super(e, parent);
2564 this.isHeaderCell = isHeaderCell;
2565 }
2566
2567 /*
2568 * Returns whether this table cell is a header
2569 */
2570 public boolean isHeaderCell() {
2571 return this.isHeaderCell;
2572 }
2573
2574 /*
2575 * Returns the Accessible representing this table cell
2576 */
2577 public Accessible getAccessible() {
2578 accessible = null;
2579 getAccessible(this);
2580 return accessible;
2581 }
2582
2583 /*
2584 * Gets the outermost Accessible in the table cell
2585 */
2586 private void getAccessible(ElementInfo elementInfo) {
2587 if (elementInfo instanceof Accessible) {
2588 accessible = (Accessible)elementInfo;
2589 } else {
2590 for (int i = 0; i < elementInfo.getChildCount(); i++) {
2591 getAccessible(elementInfo.getChild(i));
2592 }
2593 }
2594 }
2595
2596 /**
2597 * Returns the rowspan attribute.
2598 */
2599 public int getRowCount() {
2600 if (validateIfNecessary()) {
2601 return Math.max(1, getIntAttr(getAttributes(),
2602 HTML.Attribute.ROWSPAN, 1));
2603 }
2604 return 0;
2605 }
2606
2607 /**
2608 * Returns the colspan attribute.
2609 */
2610 public int getColumnCount() {
2611 if (validateIfNecessary()) {
2612 return Math.max(1, getIntAttr(getAttributes(),
2613 HTML.Attribute.COLSPAN, 1));
2614 }
2615 return 0;
2616 }
2617
2618 /**
2619 * Overriden to invalidate the TableRowElementInfo as well as
2620 * the TableCellElementInfo.
2621 */
2622 protected void invalidate(boolean first) {
2623 super.invalidate(first);
2624 getParent().invalidate(true);
2625 }
2626 }
2627 }
2628
2629
2630 /**
2631 * ElementInfo provides a slim down view of an Element. Each ElementInfo
2632 * can have any number of child ElementInfos that are not necessarily
2633 * direct children of the Element. As the Document changes various
2634 * ElementInfos become invalidated. Before accessing a particular portion
2635 * of an ElementInfo you should make sure it is valid by invoking
2636 * <code>validateIfNecessary</code>, this will return true if
2637 * successful, on the other hand a false return value indicates the
2638 * ElementInfo is not valid and can never become valid again (usually
2639 * the result of the Element the ElementInfo encapsulates being removed).
2640 */
2641 private class ElementInfo {
2642
2643 /**
2644 * The children of this ElementInfo.
2645 */
2646 private ArrayList<ElementInfo> children;
2647 /**
2648 * The Element this ElementInfo is providing information for.
2649 */
2650 private Element element;
2651 /**
2652 * The parent ElementInfo, will be null for the root.
2653 */
2654 private ElementInfo parent;
2655 /**
2656 * Indicates the validity of the ElementInfo.
2657 */
2658 private boolean isValid;
2659 /**
2660 * Indicates if the ElementInfo can become valid.
2661 */
2662 private boolean canBeValid;
2663
2664
2665 /**
2666 * Creates the root ElementInfo.
2667 */
2668 ElementInfo(Element element) {
2669 this(element, null);
2670 }
2671
2672 /**
2673 * Creates an ElementInfo representing <code>element</code> with
2674 * the specified parent.
2675 */
2676 ElementInfo(Element element, ElementInfo parent) {
2677 this.element = element;
2678 this.parent = parent;
2679 isValid = false;
2680 canBeValid = true;
2681 }
2682
2683 /**
2684 * Validates the receiver. This recreates the children as well. This
2685 * will be invoked within a <code>readLock</code>. If this is overriden
2686 * it MUST invoke supers implementation first!
2687 */
2688 protected void validate() {
2689 isValid = true;
2690 loadChildren(getElement());
2691 }
2692
2693 /**
2694 * Recreates the direct children of <code>info</code>.
2695 */
2696 protected void loadChildren(Element parent) {
2697 if (!parent.isLeaf()) {
2698 for (int counter = 0, maxCounter = parent.getElementCount();
2699 counter < maxCounter; counter++) {
2700 Element e = parent.getElement(counter);
2701 ElementInfo childInfo = createElementInfo(e, this);
2702
2703 if (childInfo != null) {
2704 addChild(childInfo);
2705 }
2706 else {
2707 loadChildren(e);
2708 }
2709 }
2710 }
2711 }
2712
2713 /**
2714 * Returns the index of the child in the parent, or -1 for the
2715 * root or if the parent isn't valid.
2716 */
2717 public int getIndexInParent() {
2718 if (parent == null || !parent.isValid()) {
2719 return -1;
2720 }
2721 return parent.indexOf(this);
2722 }
2723
2724 /**
2725 * Returns the Element this <code>ElementInfo</code> represents.
2726 */
2727 public Element getElement() {
2728 return element;
2729 }
2730
2731 /**
2732 * Returns the parent of this Element, or null for the root.
2733 */
2734 public ElementInfo getParent() {
2735 return parent;
2736 }
2737
2738 /**
2739 * Returns the index of the specified child, or -1 if
2740 * <code>child</code> isn't a valid child.
2741 */
2742 public int indexOf(ElementInfo child) {
2743 ArrayList children = this.children;
2744
2745 if (children != null) {
2746 return children.indexOf(child);
2747 }
2748 return -1;
2749 }
2750
2751 /**
2752 * Returns the child ElementInfo at <code>index</code>, or null
2753 * if <code>index</code> isn't a valid index.
2754 */
2755 public ElementInfo getChild(int index) {
2756 if (validateIfNecessary()) {
2757 ArrayList<ElementInfo> children = this.children;
2758
2759 if (children != null && index >= 0 &&
2760 index < children.size()) {
2761 return children.get(index);
2762 }
2763 }
2764 return null;
2765 }
2766
2767 /**
2768 * Returns the number of children the ElementInfo contains.
2769 */
2770 public int getChildCount() {
2771 validateIfNecessary();
2772 return (children == null) ? 0 : children.size();
2773 }
2774
2775 /**
2776 * Adds a new child to this ElementInfo.
2777 */
2778 protected void addChild(ElementInfo child) {
2779 if (children == null) {
2780 children = new ArrayList<ElementInfo>();
2781 }
2782 children.add(child);
2783 }
2784
2785 /**
2786 * Returns the View corresponding to this ElementInfo, or null
2787 * if the ElementInfo can't be validated.
2788 */
2789 protected View getView() {
2790 if (!validateIfNecessary()) {
2791 return null;
2792 }
2793 Object lock = lock();
2794 try {
2795 View rootView = getRootView();
2796 Element e = getElement();
2797 int start = e.getStartOffset();
2798
2799 if (rootView != null) {
2800 return getView(rootView, e, start);
2801 }
2802 return null;
2803 } finally {
2804 unlock(lock);
2805 }
2806 }
2807
2808 /**
2809 * Returns the Bounds for this ElementInfo, or null
2810 * if the ElementInfo can't be validated.
2811 */
2812 public Rectangle getBounds() {
2813 if (!validateIfNecessary()) {
2814 return null;
2815 }
2816 Object lock = lock();
2817 try {
2818 Rectangle bounds = getRootEditorRect();
2819 View rootView = getRootView();
2820 Element e = getElement();
2821
2822 if (bounds != null && rootView != null) {
2823 try {
2824 return rootView.modelToView(e.getStartOffset(),
2825 Position.Bias.Forward,
2826 e.getEndOffset(),
2827 Position.Bias.Backward,
2828 bounds).getBounds();
2829 } catch (BadLocationException ble) { }
2830 }
2831 } finally {
2832 unlock(lock);
2833 }
2834 return null;
2835 }
2836
2837 /**
2838 * Returns true if this ElementInfo is valid.
2839 */
2840 protected boolean isValid() {
2841 return isValid;
2842 }
2843
2844 /**
2845 * Returns the AttributeSet associated with the Element, this will
2846 * return null if the ElementInfo can't be validated.
2847 */
2848 protected AttributeSet getAttributes() {
2849 if (validateIfNecessary()) {
2850 return getElement().getAttributes();
2851 }
2852 return null;
2853 }
2854
2855 /**
2856 * Returns the AttributeSet associated with the View that is
2857 * representing this Element, this will
2858 * return null if the ElementInfo can't be validated.
2859 */
2860 protected AttributeSet getViewAttributes() {
2861 if (validateIfNecessary()) {
2862 View view = getView();
2863
2864 if (view != null) {
2865 return view.getElement().getAttributes();
2866 }
2867 return getElement().getAttributes();
2868 }
2869 return null;
2870 }
2871
2872 /**
2873 * Convenience method for getting an integer attribute from the passed
2874 * in AttributeSet.
2875 */
2876 protected int getIntAttr(AttributeSet attrs, Object key, int deflt) {
2877 if (attrs != null && attrs.isDefined(key)) {
2878 int i;
2879 String val = (String)attrs.getAttribute(key);
2880 if (val == null) {
2881 i = deflt;
2882 }
2883 else {
2884 try {
2885 i = Math.max(0, Integer.parseInt(val));
2886 } catch (NumberFormatException x) {
2887 i = deflt;
2888 }
2889 }
2890 return i;
2891 }
2892 return deflt;
2893 }
2894
2895 /**
2896 * Validates the ElementInfo if necessary. Some ElementInfos may
2897 * never be valid again. You should check <code>isValid</code> before
2898 * using one. This will reload the children and invoke
2899 * <code>validate</code> if the ElementInfo is invalid and can become
2900 * valid again. This will return true if the receiver is valid.
2901 */
2902 protected boolean validateIfNecessary() {
2903 if (!isValid() && canBeValid) {
2904 children = null;
2905 Object lock = lock();
2906
2907 try {
2908 validate();
2909 } finally {
2910 unlock(lock);
2911 }
2912 }
2913 return isValid();
2914 }
2915
2916 /**
2917 * Invalidates the ElementInfo. Subclasses should override this
2918 * if they need to reset state once invalid.
2919 */
2920 protected void invalidate(boolean first) {
2921 if (!isValid()) {
2922 if (canBeValid && !first) {
2923 canBeValid = false;
2924 }
2925 return;
2926 }
2927 isValid = false;
2928 canBeValid = first;
2929 if (children != null) {
2930 for (ElementInfo child : children) {
2931 child.invalidate(false);
2932 }
2933 children = null;
2934 }
2935 }
2936
2937 private View getView(View parent, Element e, int start) {
2938 if (parent.getElement() == e) {
2939 return parent;
2940 }
2941 int index = parent.getViewIndex(start, Position.Bias.Forward);
2942
2943 if (index != -1 && index < parent.getViewCount()) {
2944 return getView(parent.getView(index), e, start);
2945 }
2946 return null;
2947 }
2948
2949 private int getClosestInfoIndex(int index) {
2950 for (int counter = 0; counter < getChildCount(); counter++) {
2951 ElementInfo info = getChild(counter);
2952
2953 if (index < info.getElement().getEndOffset() ||
2954 index == info.getElement().getStartOffset()) {
2955 return counter;
2956 }
2957 }
2958 return -1;
2959 }
2960
2961 private void update(DocumentEvent e) {
2962 if (!isValid()) {
2963 return;
2964 }
2965 ElementInfo parent = getParent();
2966 Element element = getElement();
2967
2968 do {
2969 DocumentEvent.ElementChange ec = e.getChange(element);
2970 if (ec != null) {
2971 if (element == getElement()) {
2972 // One of our children changed.
2973 invalidate(true);
2974 }
2975 else if (parent != null) {
2976 parent.invalidate(parent == getRootInfo());
2977 }
2978 return;
2979 }
2980 element = element.getParentElement();
2981 } while (parent != null && element != null &&
2982 element != parent.getElement());
2983
2984 if (getChildCount() > 0) {
2985 Element elem = getElement();
2986 int pos = e.getOffset();
2987 int index0 = getClosestInfoIndex(pos);
2988 if (index0 == -1 &&
2989 e.getType() == DocumentEvent.EventType.REMOVE &&
2990 pos >= elem.getEndOffset()) {
2991 // Event beyond our offsets. We may have represented this,
2992 // that is the remove may have removed one of our child
2993 // Elements that represented this, so, we should foward
2994 // to last element.
2995 index0 = getChildCount() - 1;
2996 }
2997 ElementInfo info = (index0 >= 0) ? getChild(index0) : null;
2998 if (info != null &&
2999 (info.getElement().getStartOffset() == pos) && (pos > 0)) {
3000 // If at a boundary, forward the event to the previous
3001 // ElementInfo too.
3002 index0 = Math.max(index0 - 1, 0);
3003 }
3004 int index1;
3005 if (e.getType() != DocumentEvent.EventType.REMOVE) {
3006 index1 = getClosestInfoIndex(pos + e.getLength());
3007 if (index1 < 0) {
3008 index1 = getChildCount() - 1;
3009 }
3010 }
3011 else {
3012 index1 = index0;
3013 // A remove may result in empty elements.
3014 while ((index1 + 1) < getChildCount() &&
3015 getChild(index1 + 1).getElement().getEndOffset() ==
3016 getChild(index1 + 1).getElement().getStartOffset()){
3017 index1++;
3018 }
3019 }
3020 index0 = Math.max(index0, 0);
3021 // The check for isValid is here as in the process of
3022 // forwarding update our child may invalidate us.
3023 for (int i = index0; i <= index1 && isValid(); i++) {
3024 getChild(i).update(e);
3025 }
3026 }
3027 }
3028 }
3029
3030 /**
3031 * DocumentListener installed on the current Document. Will invoke
3032 * <code>update</code> on the <code>RootInfo</code> in response to
3033 * any event.
3034 */
3035 private class DocumentHandler implements DocumentListener {
3036 public void insertUpdate(DocumentEvent e) {
3037 getRootInfo().update(e);
3038 }
3039 public void removeUpdate(DocumentEvent e) {
3040 getRootInfo().update(e);
3041 }
3042 public void changedUpdate(DocumentEvent e) {
3043 getRootInfo().update(e);
3044 }
3045 }
3046
3047 /*
3048 * PropertyChangeListener installed on the editor.
3049 */
3050 private class PropertyChangeHandler implements PropertyChangeListener {
3051 public void propertyChange(PropertyChangeEvent evt) {
3052 if (evt.getPropertyName().equals("document")) {
3053 // handle the document change
3054 setDocument(editor.getDocument());
3055 }
3056 }
3057 }
3058}