| /* |
| * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package javax.swing.text.html; |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.beans.*; |
| import java.util.*; |
| import javax.swing.*; |
| import javax.swing.event.*; |
| import javax.swing.text.*; |
| import javax.accessibility.*; |
| import java.text.BreakIterator; |
| |
| /* |
| * The AccessibleHTML class provide information about the contents |
| * of a HTML document to assistive technologies. |
| * |
| * @author Lynn Monsanto |
| */ |
| class AccessibleHTML implements Accessible { |
| |
| /** |
| * The editor. |
| */ |
| private JEditorPane editor; |
| /** |
| * Current model. |
| */ |
| private Document model; |
| /** |
| * DocumentListener installed on the current model. |
| */ |
| private DocumentListener docListener; |
| /** |
| * PropertyChangeListener installed on the editor |
| */ |
| private PropertyChangeListener propChangeListener; |
| /** |
| * The root ElementInfo for the document |
| */ |
| private ElementInfo rootElementInfo; |
| /* |
| * The root accessible context for the document |
| */ |
| private RootHTMLAccessibleContext rootHTMLAccessibleContext; |
| |
| public AccessibleHTML(JEditorPane pane) { |
| editor = pane; |
| propChangeListener = new PropertyChangeHandler(); |
| setDocument(editor.getDocument()); |
| |
| docListener = new DocumentHandler(); |
| } |
| |
| /** |
| * Sets the document. |
| */ |
| private void setDocument(Document document) { |
| if (model != null) { |
| model.removeDocumentListener(docListener); |
| } |
| if (editor != null) { |
| editor.removePropertyChangeListener(propChangeListener); |
| } |
| this.model = document; |
| if (model != null) { |
| if (rootElementInfo != null) { |
| rootElementInfo.invalidate(false); |
| } |
| buildInfo(); |
| model.addDocumentListener(docListener); |
| } |
| else { |
| rootElementInfo = null; |
| } |
| if (editor != null) { |
| editor.addPropertyChangeListener(propChangeListener); |
| } |
| } |
| |
| /** |
| * Returns the Document currently presenting information for. |
| */ |
| private Document getDocument() { |
| return model; |
| } |
| |
| /** |
| * Returns the JEditorPane providing information for. |
| */ |
| private JEditorPane getTextComponent() { |
| return editor; |
| } |
| |
| /** |
| * Returns the ElementInfo representing the root Element. |
| */ |
| private ElementInfo getRootInfo() { |
| return rootElementInfo; |
| } |
| |
| /** |
| * Returns the root <code>View</code> associated with the current text |
| * component. |
| */ |
| private View getRootView() { |
| return getTextComponent().getUI().getRootView(getTextComponent()); |
| } |
| |
| /** |
| * Returns the bounds the root View will be rendered in. |
| */ |
| private Rectangle getRootEditorRect() { |
| Rectangle alloc = getTextComponent().getBounds(); |
| if ((alloc.width > 0) && (alloc.height > 0)) { |
| alloc.x = alloc.y = 0; |
| Insets insets = editor.getInsets(); |
| alloc.x += insets.left; |
| alloc.y += insets.top; |
| alloc.width -= insets.left + insets.right; |
| alloc.height -= insets.top + insets.bottom; |
| return alloc; |
| } |
| return null; |
| } |
| |
| /** |
| * If possible acquires a lock on the Document. If a lock has been |
| * obtained a key will be retured that should be passed to |
| * <code>unlock</code>. |
| */ |
| private Object lock() { |
| Document document = getDocument(); |
| |
| if (document instanceof AbstractDocument) { |
| ((AbstractDocument)document).readLock(); |
| return document; |
| } |
| return null; |
| } |
| |
| /** |
| * Releases a lock previously obtained via <code>lock</code>. |
| */ |
| private void unlock(Object key) { |
| if (key != null) { |
| ((AbstractDocument)key).readUnlock(); |
| } |
| } |
| |
| /** |
| * Rebuilds the information from the current info. |
| */ |
| private void buildInfo() { |
| Object lock = lock(); |
| |
| try { |
| Document doc = getDocument(); |
| Element root = doc.getDefaultRootElement(); |
| |
| rootElementInfo = new ElementInfo(root); |
| rootElementInfo.validate(); |
| } finally { |
| unlock(lock); |
| } |
| } |
| |
| /* |
| * Create an ElementInfo subclass based on the passed in Element. |
| */ |
| ElementInfo createElementInfo(Element e, ElementInfo parent) { |
| AttributeSet attrs = e.getAttributes(); |
| |
| if (attrs != null) { |
| Object name = attrs.getAttribute(StyleConstants.NameAttribute); |
| |
| if (name == HTML.Tag.IMG) { |
| return new IconElementInfo(e, parent); |
| } |
| else if (name == HTML.Tag.CONTENT || name == HTML.Tag.CAPTION) { |
| return new TextElementInfo(e, parent); |
| } |
| else if (name == HTML.Tag.TABLE) { |
| return new TableElementInfo(e, parent); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the root AccessibleContext for the document |
| */ |
| public AccessibleContext getAccessibleContext() { |
| if (rootHTMLAccessibleContext == null) { |
| rootHTMLAccessibleContext = |
| new RootHTMLAccessibleContext(rootElementInfo); |
| } |
| return rootHTMLAccessibleContext; |
| } |
| |
| /* |
| * The roow AccessibleContext for the document |
| */ |
| private class RootHTMLAccessibleContext extends HTMLAccessibleContext { |
| |
| public RootHTMLAccessibleContext(ElementInfo elementInfo) { |
| super(elementInfo); |
| } |
| |
| /** |
| * Gets the accessibleName property of this object. The accessibleName |
| * property of an object is a localized String that designates the purpose |
| * of the object. For example, the accessibleName property of a label |
| * or button might be the text of the label or button itself. In the |
| * case of an object that doesn't display its name, the accessibleName |
| * should still be set. For example, in the case of a text field used |
| * to enter the name of a city, the accessibleName for the en_US locale |
| * could be 'city.' |
| * |
| * @return the localized name of the object; null if this |
| * object does not have a name |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleName() { |
| if (model != null) { |
| return (String)model.getProperty(Document.TitleProperty); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the accessibleDescription property of this object. If this |
| * property isn't set, returns the content type of this |
| * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text"). |
| * |
| * @return the localized description of the object; <code>null</code> |
| * if this object does not have a description |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleDescription() { |
| return editor.getContentType(); |
| } |
| |
| /** |
| * Gets the role of this object. The role of the object is the generic |
| * purpose or use of the class of this object. For example, the role |
| * of a push button is AccessibleRole.PUSH_BUTTON. The roles in |
| * AccessibleRole are provided so component developers can pick from |
| * a set of predefined roles. This enables assistive technologies to |
| * provide a consistent interface to various tweaked subclasses of |
| * components (e.g., use AccessibleRole.PUSH_BUTTON for all components |
| * that act like a push button) as well as distinguish between subclasses |
| * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes |
| * and AccessibleRole.RADIO_BUTTON for radio buttons). |
| * <p>Note that the AccessibleRole class is also extensible, so |
| * custom component developers can define their own AccessibleRole's |
| * if the set of predefined roles is inadequate. |
| * |
| * @return an instance of AccessibleRole describing the role of the object |
| * @see AccessibleRole |
| */ |
| public AccessibleRole getAccessibleRole() { |
| return AccessibleRole.TEXT; |
| } |
| } |
| |
| /* |
| * Base AccessibleContext class for HTML elements |
| */ |
| protected abstract class HTMLAccessibleContext extends AccessibleContext |
| implements Accessible, AccessibleComponent { |
| |
| protected ElementInfo elementInfo; |
| |
| public HTMLAccessibleContext(ElementInfo elementInfo) { |
| this.elementInfo = elementInfo; |
| } |
| |
| // begin AccessibleContext implementation ... |
| public AccessibleContext getAccessibleContext() { |
| return this; |
| } |
| |
| /** |
| * Gets the state set of this object. |
| * |
| * @return an instance of AccessibleStateSet describing the states |
| * of the object |
| * @see AccessibleStateSet |
| */ |
| public AccessibleStateSet getAccessibleStateSet() { |
| AccessibleStateSet states = new AccessibleStateSet(); |
| Component comp = getTextComponent(); |
| |
| if (comp.isEnabled()) { |
| states.add(AccessibleState.ENABLED); |
| } |
| if (comp instanceof JTextComponent && |
| ((JTextComponent)comp).isEditable()) { |
| |
| states.add(AccessibleState.EDITABLE); |
| states.add(AccessibleState.FOCUSABLE); |
| } |
| if (comp.isVisible()) { |
| states.add(AccessibleState.VISIBLE); |
| } |
| if (comp.isShowing()) { |
| states.add(AccessibleState.SHOWING); |
| } |
| return states; |
| } |
| |
| /** |
| * Gets the 0-based index of this object in its accessible parent. |
| * |
| * @return the 0-based index of this object in its parent; -1 if this |
| * object does not have an accessible parent. |
| * |
| * @see #getAccessibleParent |
| * @see #getAccessibleChildrenCount |
| * @see #getAccessibleChild |
| */ |
| public int getAccessibleIndexInParent() { |
| return elementInfo.getIndexInParent(); |
| } |
| |
| /** |
| * Returns the number of accessible children of the object. |
| * |
| * @return the number of accessible children of the object. |
| */ |
| public int getAccessibleChildrenCount() { |
| return elementInfo.getChildCount(); |
| } |
| |
| /** |
| * Returns the specified Accessible child of the object. The Accessible |
| * children of an Accessible object are zero-based, so the first child |
| * of an Accessible child is at index 0, the second child is at index 1, |
| * and so on. |
| * |
| * @param i zero-based index of child |
| * @return the Accessible child of the object |
| * @see #getAccessibleChildrenCount |
| */ |
| public Accessible getAccessibleChild(int i) { |
| ElementInfo childInfo = elementInfo.getChild(i); |
| if (childInfo != null && childInfo instanceof Accessible) { |
| return (Accessible)childInfo; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the locale of the component. If the component does not have a |
| * locale, then the locale of its parent is returned. |
| * |
| * @return this component's locale. If this component does not have |
| * a locale, the locale of its parent is returned. |
| * |
| * @exception IllegalComponentStateException |
| * If the Component does not have its own locale and has not yet been |
| * added to a containment hierarchy such that the locale can be |
| * determined from the containing parent. |
| */ |
| public Locale getLocale() throws IllegalComponentStateException { |
| return editor.getLocale(); |
| } |
| // ... end AccessibleContext implementation |
| |
| // begin AccessibleComponent implementation ... |
| public AccessibleComponent getAccessibleComponent() { |
| return this; |
| } |
| |
| /** |
| * Gets the background color of this object. |
| * |
| * @return the background color, if supported, of the object; |
| * otherwise, null |
| * @see #setBackground |
| */ |
| public Color getBackground() { |
| return getTextComponent().getBackground(); |
| } |
| |
| /** |
| * Sets the background color of this object. |
| * |
| * @param c the new Color for the background |
| * @see #setBackground |
| */ |
| public void setBackground(Color c) { |
| getTextComponent().setBackground(c); |
| } |
| |
| /** |
| * Gets the foreground color of this object. |
| * |
| * @return the foreground color, if supported, of the object; |
| * otherwise, null |
| * @see #setForeground |
| */ |
| public Color getForeground() { |
| return getTextComponent().getForeground(); |
| } |
| |
| /** |
| * Sets the foreground color of this object. |
| * |
| * @param c the new Color for the foreground |
| * @see #getForeground |
| */ |
| public void setForeground(Color c) { |
| getTextComponent().setForeground(c); |
| } |
| |
| /** |
| * Gets the Cursor of this object. |
| * |
| * @return the Cursor, if supported, of the object; otherwise, null |
| * @see #setCursor |
| */ |
| public Cursor getCursor() { |
| return getTextComponent().getCursor(); |
| } |
| |
| /** |
| * Sets the Cursor of this object. |
| * |
| * @param cursor the new Cursor for the object |
| * @see #getCursor |
| */ |
| public void setCursor(Cursor cursor) { |
| getTextComponent().setCursor(cursor); |
| } |
| |
| /** |
| * Gets the Font of this object. |
| * |
| * @return the Font,if supported, for the object; otherwise, null |
| * @see #setFont |
| */ |
| public Font getFont() { |
| return getTextComponent().getFont(); |
| } |
| |
| /** |
| * Sets the Font of this object. |
| * |
| * @param f the new Font for the object |
| * @see #getFont |
| */ |
| public void setFont(Font f) { |
| getTextComponent().setFont(f); |
| } |
| |
| /** |
| * Gets the FontMetrics of this object. |
| * |
| * @param f the Font |
| * @return the FontMetrics, if supported, the object; otherwise, null |
| * @see #getFont |
| */ |
| public FontMetrics getFontMetrics(Font f) { |
| return getTextComponent().getFontMetrics(f); |
| } |
| |
| /** |
| * Determines if the object is enabled. Objects that are enabled |
| * will also have the AccessibleState.ENABLED state set in their |
| * AccessibleStateSets. |
| * |
| * @return true if object is enabled; otherwise, false |
| * @see #setEnabled |
| * @see AccessibleContext#getAccessibleStateSet |
| * @see AccessibleState#ENABLED |
| * @see AccessibleStateSet |
| */ |
| public boolean isEnabled() { |
| return getTextComponent().isEnabled(); |
| } |
| |
| /** |
| * Sets the enabled state of the object. |
| * |
| * @param b if true, enables this object; otherwise, disables it |
| * @see #isEnabled |
| */ |
| public void setEnabled(boolean b) { |
| getTextComponent().setEnabled(b); |
| } |
| |
| /** |
| * Determines if the object is visible. Note: this means that the |
| * object intends to be visible; however, it may not be |
| * showing on the screen because one of the objects that this object |
| * is contained by is currently not visible. To determine if an object |
| * is showing on the screen, use isShowing(). |
| * <p>Objects that are visible will also have the |
| * AccessibleState.VISIBLE state set in their AccessibleStateSets. |
| * |
| * @return true if object is visible; otherwise, false |
| * @see #setVisible |
| * @see AccessibleContext#getAccessibleStateSet |
| * @see AccessibleState#VISIBLE |
| * @see AccessibleStateSet |
| */ |
| public boolean isVisible() { |
| return getTextComponent().isVisible(); |
| } |
| |
| /** |
| * Sets the visible state of the object. |
| * |
| * @param b if true, shows this object; otherwise, hides it |
| * @see #isVisible |
| */ |
| public void setVisible(boolean b) { |
| getTextComponent().setVisible(b); |
| } |
| |
| /** |
| * Determines if the object is showing. This is determined by checking |
| * the visibility of the object and its ancestors. |
| * Note: this |
| * will return true even if the object is obscured by another (for |
| * example, it is underneath a menu that was pulled down). |
| * |
| * @return true if object is showing; otherwise, false |
| */ |
| public boolean isShowing() { |
| return getTextComponent().isShowing(); |
| } |
| |
| /** |
| * Checks whether the specified point is within this object's bounds, |
| * where the point's x and y coordinates are defined to be relative |
| * to the coordinate system of the object. |
| * |
| * @param p the Point relative to the coordinate system of the object |
| * @return true if object contains Point; otherwise false |
| * @see #getBounds |
| */ |
| public boolean contains(Point p) { |
| Rectangle r = getBounds(); |
| if (r != null) { |
| return r.contains(p.x, p.y); |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Returns the location of the object on the screen. |
| * |
| * @return the location of the object on screen; null if this object |
| * is not on the screen |
| * @see #getBounds |
| * @see #getLocation |
| */ |
| public Point getLocationOnScreen() { |
| Point editorLocation = getTextComponent().getLocationOnScreen(); |
| Rectangle r = getBounds(); |
| if (r != null) { |
| return new Point(editorLocation.x + r.x, |
| editorLocation.y + r.y); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the location of the object relative to the parent in the form |
| * of a point specifying the object's top-left corner in the screen's |
| * coordinate space. |
| * |
| * @return An instance of Point representing the top-left corner of the |
| * object's bounds in the coordinate space of the screen; null if |
| * this object or its parent are not on the screen |
| * @see #getBounds |
| * @see #getLocationOnScreen |
| */ |
| public Point getLocation() { |
| Rectangle r = getBounds(); |
| if (r != null) { |
| return new Point(r.x, r.y); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Sets the location of the object relative to the parent. |
| * @param p the new position for the top-left corner |
| * @see #getLocation |
| */ |
| public void setLocation(Point p) { |
| } |
| |
| /** |
| * Gets the bounds of this object in the form of a Rectangle object. |
| * The bounds specify this object's width, height, and location |
| * relative to its parent. |
| * |
| * @return A rectangle indicating this component's bounds; null if |
| * this object is not on the screen. |
| * @see #contains |
| */ |
| public Rectangle getBounds() { |
| return elementInfo.getBounds(); |
| } |
| |
| /** |
| * Sets the bounds of this object in the form of a Rectangle object. |
| * The bounds specify this object's width, height, and location |
| * relative to its parent. |
| * |
| * @param r rectangle indicating this component's bounds |
| * @see #getBounds |
| */ |
| public void setBounds(Rectangle r) { |
| } |
| |
| /** |
| * Returns the size of this object in the form of a Dimension object. |
| * The height field of the Dimension object contains this object's |
| * height, and the width field of the Dimension object contains this |
| * object's width. |
| * |
| * @return A Dimension object that indicates the size of this component; |
| * null if this object is not on the screen |
| * @see #setSize |
| */ |
| public Dimension getSize() { |
| Rectangle r = getBounds(); |
| if (r != null) { |
| return new Dimension(r.width, r.height); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Resizes this object so that it has width and height. |
| * |
| * @param d The dimension specifying the new size of the object. |
| * @see #getSize |
| */ |
| public void setSize(Dimension d) { |
| Component comp = getTextComponent(); |
| comp.setSize(d); |
| } |
| |
| /** |
| * Returns the Accessible child, if one exists, contained at the local |
| * coordinate Point. |
| * |
| * @param p The point relative to the coordinate system of this object. |
| * @return the Accessible, if it exists, at the specified location; |
| * otherwise null |
| */ |
| public Accessible getAccessibleAt(Point p) { |
| ElementInfo innerMostElement = getElementInfoAt(rootElementInfo, p); |
| if (innerMostElement instanceof Accessible) { |
| return (Accessible)innerMostElement; |
| } else { |
| return null; |
| } |
| } |
| |
| private ElementInfo getElementInfoAt(ElementInfo elementInfo, Point p) { |
| if (elementInfo.getBounds() == null) { |
| return null; |
| } |
| if (elementInfo.getChildCount() == 0 && |
| elementInfo.getBounds().contains(p)) { |
| return elementInfo; |
| |
| } else { |
| if (elementInfo instanceof TableElementInfo) { |
| // Handle table caption as a special case since it's the |
| // only table child that is not a table row. |
| ElementInfo captionInfo = |
| ((TableElementInfo)elementInfo).getCaptionInfo(); |
| if (captionInfo != null) { |
| Rectangle bounds = captionInfo.getBounds(); |
| if (bounds != null && bounds.contains(p)) { |
| return captionInfo; |
| } |
| } |
| } |
| for (int i = 0; i < elementInfo.getChildCount(); i++) |
| { |
| ElementInfo childInfo = elementInfo.getChild(i); |
| ElementInfo retValue = getElementInfoAt(childInfo, p); |
| if (retValue != null) { |
| return retValue; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns whether this object can accept focus or not. Objects that |
| * can accept focus will also have the AccessibleState.FOCUSABLE state |
| * set in their AccessibleStateSets. |
| * |
| * @return true if object can accept focus; otherwise false |
| * @see AccessibleContext#getAccessibleStateSet |
| * @see AccessibleState#FOCUSABLE |
| * @see AccessibleState#FOCUSED |
| * @see AccessibleStateSet |
| */ |
| public boolean isFocusTraversable() { |
| Component comp = getTextComponent(); |
| if (comp instanceof JTextComponent) { |
| if (((JTextComponent)comp).isEditable()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Requests focus for this object. If this object cannot accept focus, |
| * nothing will happen. Otherwise, the object will attempt to take |
| * focus. |
| * @see #isFocusTraversable |
| */ |
| public void requestFocus() { |
| // TIGER - 4856191 |
| if (! isFocusTraversable()) { |
| return; |
| } |
| |
| Component comp = getTextComponent(); |
| if (comp instanceof JTextComponent) { |
| |
| comp.requestFocusInWindow(); |
| |
| try { |
| if (elementInfo.validateIfNecessary()) { |
| // set the caret position to the start of this component |
| Element elem = elementInfo.getElement(); |
| ((JTextComponent)comp).setCaretPosition(elem.getStartOffset()); |
| |
| // fire a AccessibleState.FOCUSED property change event |
| AccessibleContext ac = editor.getAccessibleContext(); |
| PropertyChangeEvent pce = new PropertyChangeEvent(this, |
| AccessibleContext.ACCESSIBLE_STATE_PROPERTY, |
| null, AccessibleState.FOCUSED); |
| ac.firePropertyChange( |
| AccessibleContext.ACCESSIBLE_STATE_PROPERTY, |
| null, pce); |
| } |
| } catch (IllegalArgumentException e) { |
| // don't fire property change event |
| } |
| } |
| } |
| |
| /** |
| * Adds the specified focus listener to receive focus events from this |
| * component. |
| * |
| * @param l the focus listener |
| * @see #removeFocusListener |
| */ |
| public void addFocusListener(FocusListener l) { |
| getTextComponent().addFocusListener(l); |
| } |
| |
| /** |
| * Removes the specified focus listener so it no longer receives focus |
| * events from this component. |
| * |
| * @param l the focus listener |
| * @see #addFocusListener |
| */ |
| public void removeFocusListener(FocusListener l) { |
| getTextComponent().removeFocusListener(l); |
| } |
| // ... end AccessibleComponent implementation |
| } // ... end HTMLAccessibleContext |
| |
| |
| |
| /* |
| * ElementInfo for text |
| */ |
| class TextElementInfo extends ElementInfo implements Accessible { |
| |
| TextElementInfo(Element element, ElementInfo parent) { |
| super(element, parent); |
| } |
| |
| // begin AccessibleText implementation ... |
| private AccessibleContext accessibleContext; |
| |
| public AccessibleContext getAccessibleContext() { |
| if (accessibleContext == null) { |
| accessibleContext = new TextAccessibleContext(this); |
| } |
| return accessibleContext; |
| } |
| |
| /* |
| * AccessibleContext for text elements |
| */ |
| public class TextAccessibleContext extends HTMLAccessibleContext |
| implements AccessibleText { |
| |
| public TextAccessibleContext(ElementInfo elementInfo) { |
| super(elementInfo); |
| } |
| |
| public AccessibleText getAccessibleText() { |
| return this; |
| } |
| |
| /** |
| * Gets the accessibleName property of this object. The accessibleName |
| * property of an object is a localized String that designates the purpose |
| * of the object. For example, the accessibleName property of a label |
| * or button might be the text of the label or button itself. In the |
| * case of an object that doesn't display its name, the accessibleName |
| * should still be set. For example, in the case of a text field used |
| * to enter the name of a city, the accessibleName for the en_US locale |
| * could be 'city.' |
| * |
| * @return the localized name of the object; null if this |
| * object does not have a name |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleName() { |
| if (model != null) { |
| return (String)model.getProperty(Document.TitleProperty); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the accessibleDescription property of this object. If this |
| * property isn't set, returns the content type of this |
| * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text"). |
| * |
| * @return the localized description of the object; <code>null</code> |
| * if this object does not have a description |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleDescription() { |
| return editor.getContentType(); |
| } |
| |
| /** |
| * Gets the role of this object. The role of the object is the generic |
| * purpose or use of the class of this object. For example, the role |
| * of a push button is AccessibleRole.PUSH_BUTTON. The roles in |
| * AccessibleRole are provided so component developers can pick from |
| * a set of predefined roles. This enables assistive technologies to |
| * provide a consistent interface to various tweaked subclasses of |
| * components (e.g., use AccessibleRole.PUSH_BUTTON for all components |
| * that act like a push button) as well as distinguish between subclasses |
| * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes |
| * and AccessibleRole.RADIO_BUTTON for radio buttons). |
| * <p>Note that the AccessibleRole class is also extensible, so |
| * custom component developers can define their own AccessibleRole's |
| * if the set of predefined roles is inadequate. |
| * |
| * @return an instance of AccessibleRole describing the role of the object |
| * @see AccessibleRole |
| */ |
| public AccessibleRole getAccessibleRole() { |
| return AccessibleRole.TEXT; |
| } |
| |
| /** |
| * Given a point in local coordinates, return the zero-based index |
| * of the character under that Point. If the point is invalid, |
| * this method returns -1. |
| * |
| * @param p the Point in local coordinates |
| * @return the zero-based index of the character under Point p; if |
| * Point is invalid returns -1. |
| */ |
| @SuppressWarnings("deprecation") |
| public int getIndexAtPoint(Point p) { |
| View v = getView(); |
| if (v != null) { |
| return v.viewToModel(p.x, p.y, getBounds()); |
| } else { |
| return -1; |
| } |
| } |
| |
| /** |
| * Determine the bounding box of the character at the given |
| * index into the string. The bounds are returned in local |
| * coordinates. If the index is invalid an empty rectangle is |
| * returned. |
| * |
| * @param i the index into the String |
| * @return the screen coordinates of the character's the bounding box, |
| * if index is invalid returns an empty rectangle. |
| */ |
| @SuppressWarnings("deprecation") |
| public Rectangle getCharacterBounds(int i) { |
| try { |
| return editor.getUI().modelToView(editor, i); |
| } catch (BadLocationException e) { |
| return null; |
| } |
| } |
| |
| /** |
| * Return the number of characters (valid indicies) |
| * |
| * @return the number of characters |
| */ |
| public int getCharCount() { |
| if (validateIfNecessary()) { |
| Element elem = elementInfo.getElement(); |
| return elem.getEndOffset() - elem.getStartOffset(); |
| } |
| return 0; |
| } |
| |
| /** |
| * Return the zero-based offset of the caret. |
| * |
| * Note: That to the right of the caret will have the same index |
| * value as the offset (the caret is between two characters). |
| * @return the zero-based offset of the caret. |
| */ |
| public int getCaretPosition() { |
| View v = getView(); |
| if (v == null) { |
| return -1; |
| } |
| Container c = v.getContainer(); |
| if (c == null) { |
| return -1; |
| } |
| if (c instanceof JTextComponent) { |
| return ((JTextComponent)c).getCaretPosition(); |
| } else { |
| return -1; |
| } |
| } |
| |
| /** |
| * IndexedSegment extends Segment adding the offset into the |
| * the model the <code>Segment</code> was asked for. |
| */ |
| private class IndexedSegment extends Segment { |
| /** |
| * Offset into the model that the position represents. |
| */ |
| public int modelOffset; |
| } |
| |
| public String getAtIndex(int part, int index) { |
| return getAtIndex(part, index, 0); |
| } |
| |
| |
| public String getAfterIndex(int part, int index) { |
| return getAtIndex(part, index, 1); |
| } |
| |
| public String getBeforeIndex(int part, int index) { |
| return getAtIndex(part, index, -1); |
| } |
| |
| /** |
| * Gets the word, sentence, or character at <code>index</code>. |
| * If <code>direction</code> is non-null this will find the |
| * next/previous word/sentence/character. |
| */ |
| private String getAtIndex(int part, int index, int direction) { |
| if (model instanceof AbstractDocument) { |
| ((AbstractDocument)model).readLock(); |
| } |
| try { |
| if (index < 0 || index >= model.getLength()) { |
| return null; |
| } |
| switch (part) { |
| case AccessibleText.CHARACTER: |
| if (index + direction < model.getLength() && |
| index + direction >= 0) { |
| return model.getText(index + direction, 1); |
| } |
| break; |
| |
| |
| case AccessibleText.WORD: |
| case AccessibleText.SENTENCE: |
| IndexedSegment seg = getSegmentAt(part, index); |
| if (seg != null) { |
| if (direction != 0) { |
| int next; |
| |
| |
| if (direction < 0) { |
| next = seg.modelOffset - 1; |
| } |
| else { |
| next = seg.modelOffset + direction * seg.count; |
| } |
| if (next >= 0 && next <= model.getLength()) { |
| seg = getSegmentAt(part, next); |
| } |
| else { |
| seg = null; |
| } |
| } |
| if (seg != null) { |
| return new String(seg.array, seg.offset, |
| seg.count); |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } catch (BadLocationException e) { |
| } finally { |
| if (model instanceof AbstractDocument) { |
| ((AbstractDocument)model).readUnlock(); |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Returns the paragraph element for the specified index. |
| */ |
| private Element getParagraphElement(int index) { |
| if (model instanceof PlainDocument ) { |
| PlainDocument sdoc = (PlainDocument)model; |
| return sdoc.getParagraphElement(index); |
| } else if (model instanceof StyledDocument) { |
| StyledDocument sdoc = (StyledDocument)model; |
| return sdoc.getParagraphElement(index); |
| } else { |
| Element para; |
| for (para = model.getDefaultRootElement(); ! para.isLeaf(); ) { |
| int pos = para.getElementIndex(index); |
| para = para.getElement(pos); |
| } |
| if (para == null) { |
| return null; |
| } |
| return para.getParentElement(); |
| } |
| } |
| |
| /* |
| * Returns a <code>Segment</code> containing the paragraph text |
| * at <code>index</code>, or null if <code>index</code> isn't |
| * valid. |
| */ |
| private IndexedSegment getParagraphElementText(int index) |
| throws BadLocationException { |
| Element para = getParagraphElement(index); |
| |
| |
| if (para != null) { |
| IndexedSegment segment = new IndexedSegment(); |
| try { |
| int length = para.getEndOffset() - para.getStartOffset(); |
| model.getText(para.getStartOffset(), length, segment); |
| } catch (BadLocationException e) { |
| return null; |
| } |
| segment.modelOffset = para.getStartOffset(); |
| return segment; |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Returns the Segment at <code>index</code> representing either |
| * the paragraph or sentence as identified by <code>part</code>, or |
| * null if a valid paragraph/sentence can't be found. The offset |
| * will point to the start of the word/sentence in the array, and |
| * the modelOffset will point to the location of the word/sentence |
| * in the model. |
| */ |
| private IndexedSegment getSegmentAt(int part, int index) |
| throws BadLocationException { |
| |
| IndexedSegment seg = getParagraphElementText(index); |
| if (seg == null) { |
| return null; |
| } |
| BreakIterator iterator; |
| switch (part) { |
| case AccessibleText.WORD: |
| iterator = BreakIterator.getWordInstance(getLocale()); |
| break; |
| case AccessibleText.SENTENCE: |
| iterator = BreakIterator.getSentenceInstance(getLocale()); |
| break; |
| default: |
| return null; |
| } |
| seg.first(); |
| iterator.setText(seg); |
| int end = iterator.following(index - seg.modelOffset + seg.offset); |
| if (end == BreakIterator.DONE) { |
| return null; |
| } |
| if (end > seg.offset + seg.count) { |
| return null; |
| } |
| int begin = iterator.previous(); |
| if (begin == BreakIterator.DONE || |
| begin >= seg.offset + seg.count) { |
| return null; |
| } |
| seg.modelOffset = seg.modelOffset + begin - seg.offset; |
| seg.offset = begin; |
| seg.count = end - begin; |
| return seg; |
| } |
| |
| /** |
| * Return the AttributeSet for a given character at a given index |
| * |
| * @param i the zero-based index into the text |
| * @return the AttributeSet of the character |
| */ |
| public AttributeSet getCharacterAttribute(int i) { |
| if (model instanceof StyledDocument) { |
| StyledDocument doc = (StyledDocument)model; |
| Element elem = doc.getCharacterElement(i); |
| if (elem != null) { |
| return elem.getAttributes(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the start offset within the selected text. |
| * If there is no selection, but there is |
| * a caret, the start and end offsets will be the same. |
| * |
| * @return the index into the text of the start of the selection |
| */ |
| public int getSelectionStart() { |
| return editor.getSelectionStart(); |
| } |
| |
| /** |
| * Returns the end offset within the selected text. |
| * If there is no selection, but there is |
| * a caret, the start and end offsets will be the same. |
| * |
| * @return the index into the text of the end of the selection |
| */ |
| public int getSelectionEnd() { |
| return editor.getSelectionEnd(); |
| } |
| |
| /** |
| * Returns the portion of the text that is selected. |
| * |
| * @return the String portion of the text that is selected |
| */ |
| public String getSelectedText() { |
| return editor.getSelectedText(); |
| } |
| |
| /* |
| * Returns the text substring starting at the specified |
| * offset with the specified length. |
| */ |
| private String getText(int offset, int length) |
| throws BadLocationException { |
| |
| if (model != null && model instanceof StyledDocument) { |
| StyledDocument doc = (StyledDocument)model; |
| return model.getText(offset, length); |
| } else { |
| return null; |
| } |
| } |
| } |
| } |
| |
| /* |
| * ElementInfo for images |
| */ |
| private class IconElementInfo extends ElementInfo implements Accessible { |
| |
| private int width = -1; |
| private int height = -1; |
| |
| IconElementInfo(Element element, ElementInfo parent) { |
| super(element, parent); |
| } |
| |
| protected void invalidate(boolean first) { |
| super.invalidate(first); |
| width = height = -1; |
| } |
| |
| private int getImageSize(Object key) { |
| if (validateIfNecessary()) { |
| int size = getIntAttr(getAttributes(), key, -1); |
| |
| if (size == -1) { |
| View v = getView(); |
| |
| size = 0; |
| if (v instanceof ImageView) { |
| Image img = ((ImageView)v).getImage(); |
| if (img != null) { |
| if (key == HTML.Attribute.WIDTH) { |
| size = img.getWidth(null); |
| } |
| else { |
| size = img.getHeight(null); |
| } |
| } |
| } |
| } |
| return size; |
| } |
| return 0; |
| } |
| |
| // begin AccessibleIcon implementation ... |
| private AccessibleContext accessibleContext; |
| |
| public AccessibleContext getAccessibleContext() { |
| if (accessibleContext == null) { |
| accessibleContext = new IconAccessibleContext(this); |
| } |
| return accessibleContext; |
| } |
| |
| /* |
| * AccessibleContext for images |
| */ |
| protected class IconAccessibleContext extends HTMLAccessibleContext |
| implements AccessibleIcon { |
| |
| public IconAccessibleContext(ElementInfo elementInfo) { |
| super(elementInfo); |
| } |
| |
| /** |
| * Gets the accessibleName property of this object. The accessibleName |
| * property of an object is a localized String that designates the purpose |
| * of the object. For example, the accessibleName property of a label |
| * or button might be the text of the label or button itself. In the |
| * case of an object that doesn't display its name, the accessibleName |
| * should still be set. For example, in the case of a text field used |
| * to enter the name of a city, the accessibleName for the en_US locale |
| * could be 'city.' |
| * |
| * @return the localized name of the object; null if this |
| * object does not have a name |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleName() { |
| return getAccessibleIconDescription(); |
| } |
| |
| /** |
| * Gets the accessibleDescription property of this object. If this |
| * property isn't set, returns the content type of this |
| * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text"). |
| * |
| * @return the localized description of the object; <code>null</code> |
| * if this object does not have a description |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleDescription() { |
| return editor.getContentType(); |
| } |
| |
| /** |
| * Gets the role of this object. The role of the object is the generic |
| * purpose or use of the class of this object. For example, the role |
| * of a push button is AccessibleRole.PUSH_BUTTON. The roles in |
| * AccessibleRole are provided so component developers can pick from |
| * a set of predefined roles. This enables assistive technologies to |
| * provide a consistent interface to various tweaked subclasses of |
| * components (e.g., use AccessibleRole.PUSH_BUTTON for all components |
| * that act like a push button) as well as distinguish between subclasses |
| * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes |
| * and AccessibleRole.RADIO_BUTTON for radio buttons). |
| * <p>Note that the AccessibleRole class is also extensible, so |
| * custom component developers can define their own AccessibleRole's |
| * if the set of predefined roles is inadequate. |
| * |
| * @return an instance of AccessibleRole describing the role of the object |
| * @see AccessibleRole |
| */ |
| public AccessibleRole getAccessibleRole() { |
| return AccessibleRole.ICON; |
| } |
| |
| public AccessibleIcon [] getAccessibleIcon() { |
| AccessibleIcon [] icons = new AccessibleIcon[1]; |
| icons[0] = this; |
| return icons; |
| } |
| |
| /** |
| * Gets the description of the icon. This is meant to be a brief |
| * textual description of the object. For example, it might be |
| * presented to a blind user to give an indication of the purpose |
| * of the icon. |
| * |
| * @return the description of the icon |
| */ |
| public String getAccessibleIconDescription() { |
| return ((ImageView)getView()).getAltText(); |
| } |
| |
| /** |
| * Sets the description of the icon. This is meant to be a brief |
| * textual description of the object. For example, it might be |
| * presented to a blind user to give an indication of the purpose |
| * of the icon. |
| * |
| * @param description the description of the icon |
| */ |
| public void setAccessibleIconDescription(String description) { |
| } |
| |
| /** |
| * Gets the width of the icon |
| * |
| * @return the width of the icon. |
| */ |
| public int getAccessibleIconWidth() { |
| if (width == -1) { |
| width = getImageSize(HTML.Attribute.WIDTH); |
| } |
| return width; |
| } |
| |
| /** |
| * Gets the height of the icon |
| * |
| * @return the height of the icon. |
| */ |
| public int getAccessibleIconHeight() { |
| if (height == -1) { |
| height = getImageSize(HTML.Attribute.HEIGHT); |
| } |
| return height; |
| } |
| } |
| // ... end AccessibleIconImplementation |
| } |
| |
| |
| /** |
| * TableElementInfo encapsulates information about a HTML.Tag.TABLE. |
| * To make access fast it crates a grid containing the children to |
| * allow for access by row, column. TableElementInfo will contain |
| * TableRowElementInfos, which will contain TableCellElementInfos. |
| * Any time one of the rows or columns becomes invalid the table is |
| * invalidated. This is because any time one of the child attributes |
| * changes the size of the grid may have changed. |
| */ |
| private class TableElementInfo extends ElementInfo |
| implements Accessible { |
| |
| protected ElementInfo caption; |
| |
| /** |
| * Allocation of the table by row x column. There may be holes (eg |
| * nulls) depending upon the html, any cell that has a rowspan/colspan |
| * > 1 will be contained multiple times in the grid. |
| */ |
| private TableCellElementInfo[][] grid; |
| |
| |
| TableElementInfo(Element e, ElementInfo parent) { |
| super(e, parent); |
| } |
| |
| public ElementInfo getCaptionInfo() { |
| return caption; |
| } |
| |
| /** |
| * Overriden to update the grid when validating. |
| */ |
| protected void validate() { |
| super.validate(); |
| updateGrid(); |
| } |
| |
| /** |
| * Overriden to only alloc instances of TableRowElementInfos. |
| */ |
| protected void loadChildren(Element e) { |
| |
| for (int counter = 0; counter < e.getElementCount(); counter++) { |
| Element child = e.getElement(counter); |
| AttributeSet attrs = child.getAttributes(); |
| |
| if (attrs.getAttribute(StyleConstants.NameAttribute) == |
| HTML.Tag.TR) { |
| addChild(new TableRowElementInfo(child, this, counter)); |
| |
| } else if (attrs.getAttribute(StyleConstants.NameAttribute) == |
| HTML.Tag.CAPTION) { |
| // Handle captions as a special case since all other |
| // children are table rows. |
| caption = createElementInfo(child, this); |
| } |
| } |
| } |
| |
| /** |
| * Updates the grid. |
| */ |
| private void updateGrid() { |
| // Determine the max row/col count. |
| int delta = 0; |
| int maxCols = 0; |
| int rows; |
| for (int counter = 0; counter < getChildCount(); counter++) { |
| TableRowElementInfo row = getRow(counter); |
| int prev = 0; |
| for (int y = 0; y < delta; y++) { |
| prev = Math.max(prev, getRow(counter - y - 1). |
| getColumnCount(y + 2)); |
| } |
| delta = Math.max(row.getRowCount(), delta); |
| delta--; |
| maxCols = Math.max(maxCols, row.getColumnCount() + prev); |
| } |
| rows = getChildCount() + delta; |
| |
| // Alloc |
| grid = new TableCellElementInfo[rows][]; |
| for (int counter = 0; counter < rows; counter++) { |
| grid[counter] = new TableCellElementInfo[maxCols]; |
| } |
| // Update |
| for (int counter = 0; counter < rows; counter++) { |
| getRow(counter).updateGrid(counter); |
| } |
| } |
| |
| /** |
| * Returns the TableCellElementInfo at the specified index. |
| */ |
| public TableRowElementInfo getRow(int index) { |
| return (TableRowElementInfo)getChild(index); |
| } |
| |
| /** |
| * Returns the TableCellElementInfo by row and column. |
| */ |
| public TableCellElementInfo getCell(int r, int c) { |
| if (validateIfNecessary() && r < grid.length && |
| c < grid[0].length) { |
| return grid[r][c]; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the rowspan of the specified entry. |
| */ |
| public int getRowExtentAt(int r, int c) { |
| TableCellElementInfo cell = getCell(r, c); |
| |
| if (cell != null) { |
| int rows = cell.getRowCount(); |
| int delta = 1; |
| |
| while ((r - delta) >= 0 && grid[r - delta][c] == cell) { |
| delta++; |
| } |
| return rows - delta + 1; |
| } |
| return 0; |
| } |
| |
| /** |
| * Returns the colspan of the specified entry. |
| */ |
| public int getColumnExtentAt(int r, int c) { |
| TableCellElementInfo cell = getCell(r, c); |
| |
| if (cell != null) { |
| int cols = cell.getColumnCount(); |
| int delta = 1; |
| |
| while ((c - delta) >= 0 && grid[r][c - delta] == cell) { |
| delta++; |
| } |
| return cols - delta + 1; |
| } |
| return 0; |
| } |
| |
| /** |
| * Returns the number of rows in the table. |
| */ |
| public int getRowCount() { |
| if (validateIfNecessary()) { |
| return grid.length; |
| } |
| return 0; |
| } |
| |
| /** |
| * Returns the number of columns in the table. |
| */ |
| public int getColumnCount() { |
| if (validateIfNecessary() && grid.length > 0) { |
| return grid[0].length; |
| } |
| return 0; |
| } |
| |
| // begin AccessibleTable implementation ... |
| private AccessibleContext accessibleContext; |
| |
| public AccessibleContext getAccessibleContext() { |
| if (accessibleContext == null) { |
| accessibleContext = new TableAccessibleContext(this); |
| } |
| return accessibleContext; |
| } |
| |
| /* |
| * AccessibleContext for tables |
| */ |
| public class TableAccessibleContext extends HTMLAccessibleContext |
| implements AccessibleTable { |
| |
| private AccessibleHeadersTable rowHeadersTable; |
| |
| public TableAccessibleContext(ElementInfo elementInfo) { |
| super(elementInfo); |
| } |
| |
| /** |
| * Gets the accessibleName property of this object. The accessibleName |
| * property of an object is a localized String that designates the purpose |
| * of the object. For example, the accessibleName property of a label |
| * or button might be the text of the label or button itself. In the |
| * case of an object that doesn't display its name, the accessibleName |
| * should still be set. For example, in the case of a text field used |
| * to enter the name of a city, the accessibleName for the en_US locale |
| * could be 'city.' |
| * |
| * @return the localized name of the object; null if this |
| * object does not have a name |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleName() { |
| // return the role of the object |
| return getAccessibleRole().toString(); |
| } |
| |
| /** |
| * Gets the accessibleDescription property of this object. If this |
| * property isn't set, returns the content type of this |
| * <code>JEditorPane</code> instead (e.g. "plain/text", "html/text"). |
| * |
| * @return the localized description of the object; <code>null</code> |
| * if this object does not have a description |
| * |
| * @see #setAccessibleName |
| */ |
| public String getAccessibleDescription() { |
| return editor.getContentType(); |
| } |
| |
| /** |
| * Gets the role of this object. The role of the object is the generic |
| * purpose or use of the class of this object. For example, the role |
| * of a push button is AccessibleRole.PUSH_BUTTON. The roles in |
| * AccessibleRole are provided so component developers can pick from |
| * a set of predefined roles. This enables assistive technologies to |
| * provide a consistent interface to various tweaked subclasses of |
| * components (e.g., use AccessibleRole.PUSH_BUTTON for all components |
| * that act like a push button) as well as distinguish between subclasses |
| * that behave differently (e.g., AccessibleRole.CHECK_BOX for check boxes |
| * and AccessibleRole.RADIO_BUTTON for radio buttons). |
| * <p>Note that the AccessibleRole class is also extensible, so |
| * custom component developers can define their own AccessibleRole's |
| * if the set of predefined roles is inadequate. |
| * |
| * @return an instance of AccessibleRole describing the role of the object |
| * @see AccessibleRole |
| */ |
| public AccessibleRole getAccessibleRole() { |
| return AccessibleRole.TABLE; |
| } |
| |
| /** |
| * Gets the 0-based index of this object in its accessible parent. |
| * |
| * @return the 0-based index of this object in its parent; -1 if this |
| * object does not have an accessible parent. |
| * |
| * @see #getAccessibleParent |
| * @see #getAccessibleChildrenCount |
| * @gsee #getAccessibleChild |
| */ |
| public int getAccessibleIndexInParent() { |
| return elementInfo.getIndexInParent(); |
| } |
| |
| /** |
| * Returns the number of accessible children of the object. |
| * |
| * @return the number of accessible children of the object. |
| */ |
| public int getAccessibleChildrenCount() { |
| return ((TableElementInfo)elementInfo).getRowCount() * |
| ((TableElementInfo)elementInfo).getColumnCount(); |
| } |
| |
| /** |
| * Returns the specified Accessible child of the object. The Accessible |
| * children of an Accessible object are zero-based, so the first child |
| * of an Accessible child is at index 0, the second child is at index 1, |
| * and so on. |
| * |
| * @param i zero-based index of child |
| * @return the Accessible child of the object |
| * @see #getAccessibleChildrenCount |
| */ |
| public Accessible getAccessibleChild(int i) { |
| int rowCount = ((TableElementInfo)elementInfo).getRowCount(); |
| int columnCount = ((TableElementInfo)elementInfo).getColumnCount(); |
| int r = i / rowCount; |
| int c = i % columnCount; |
| if (r < 0 || r >= rowCount || c < 0 || c >= columnCount) { |
| return null; |
| } else { |
| return getAccessibleAt(r, c); |
| } |
| } |
| |
| public AccessibleTable getAccessibleTable() { |
| return this; |
| } |
| |
| /** |
| * Returns the caption for the table. |
| * |
| * @return the caption for the table |
| */ |
| public Accessible getAccessibleCaption() { |
| ElementInfo captionInfo = getCaptionInfo(); |
| if (captionInfo instanceof Accessible) { |
| return (Accessible)caption; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Sets the caption for the table. |
| * |
| * @param a the caption for the table |
| */ |
| public void setAccessibleCaption(Accessible a) { |
| } |
| |
| /** |
| * Returns the summary description of the table. |
| * |
| * @return the summary description of the table |
| */ |
| public Accessible getAccessibleSummary() { |
| return null; |
| } |
| |
| /** |
| * Sets the summary description of the table |
| * |
| * @param a the summary description of the table |
| */ |
| public void setAccessibleSummary(Accessible a) { |
| } |
| |
| /** |
| * Returns the number of rows in the table. |
| * |
| * @return the number of rows in the table |
| */ |
| public int getAccessibleRowCount() { |
| return ((TableElementInfo)elementInfo).getRowCount(); |
| } |
| |
| /** |
| * Returns the number of columns in the table. |
| * |
| * @return the number of columns in the table |
| */ |
| public int getAccessibleColumnCount() { |
| return ((TableElementInfo)elementInfo).getColumnCount(); |
| } |
| |
| /** |
| * Returns the Accessible at a specified row and column |
| * in the table. |
| * |
| * @param r zero-based row of the table |
| * @param c zero-based column of the table |
| * @return the Accessible at the specified row and column |
| */ |
| public Accessible getAccessibleAt(int r, int c) { |
| TableCellElementInfo cellInfo = getCell(r, c); |
| if (cellInfo != null) { |
| return cellInfo.getAccessible(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the number of rows occupied by the Accessible at |
| * a specified row and column in the table. |
| * |
| * @return the number of rows occupied by the Accessible at a |
| * given specified (row, column) |
| */ |
| public int getAccessibleRowExtentAt(int r, int c) { |
| return ((TableElementInfo)elementInfo).getRowExtentAt(r, c); |
| } |
| |
| /** |
| * Returns the number of columns occupied by the Accessible at |
| * a specified row and column in the table. |
| * |
| * @return the number of columns occupied by the Accessible at a |
| * given specified row and column |
| */ |
| public int getAccessibleColumnExtentAt(int r, int c) { |
| return ((TableElementInfo)elementInfo).getColumnExtentAt(r, c); |
| } |
| |
| /** |
| * Returns the row headers as an AccessibleTable. |
| * |
| * @return an AccessibleTable representing the row |
| * headers |
| */ |
| public AccessibleTable getAccessibleRowHeader() { |
| return rowHeadersTable; |
| } |
| |
| /** |
| * Sets the row headers. |
| * |
| * @param table an AccessibleTable representing the |
| * row headers |
| */ |
| public void setAccessibleRowHeader(AccessibleTable table) { |
| } |
| |
| /** |
| * Returns the column headers as an AccessibleTable. |
| * |
| * @return an AccessibleTable representing the column |
| * headers |
| */ |
| public AccessibleTable getAccessibleColumnHeader() { |
| return null; |
| } |
| |
| /** |
| * Sets the column headers. |
| * |
| * @param table an AccessibleTable representing the |
| * column headers |
| */ |
| public void setAccessibleColumnHeader(AccessibleTable table) { |
| } |
| |
| /** |
| * Returns the description of the specified row in the table. |
| * |
| * @param r zero-based row of the table |
| * @return the description of the row |
| */ |
| public Accessible getAccessibleRowDescription(int r) { |
| return null; |
| } |
| |
| /** |
| * Sets the description text of the specified row of the table. |
| * |
| * @param r zero-based row of the table |
| * @param a the description of the row |
| */ |
| public void setAccessibleRowDescription(int r, Accessible a) { |
| } |
| |
| /** |
| * Returns the description text of the specified column in the table. |
| * |
| * @param c zero-based column of the table |
| * @return the text description of the column |
| */ |
| public Accessible getAccessibleColumnDescription(int c) { |
| return null; |
| } |
| |
| /** |
| * Sets the description text of the specified column in the table. |
| * |
| * @param c zero-based column of the table |
| * @param a the text description of the column |
| */ |
| public void setAccessibleColumnDescription(int c, Accessible a) { |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the accessible at |
| * a specified row and column is selected. |
| * |
| * @param r zero-based row of the table |
| * @param c zero-based column of the table |
| * @return the boolean value true if the accessible at the |
| * row and column is selected. Otherwise, the boolean value |
| * false |
| */ |
| public boolean isAccessibleSelected(int r, int c) { |
| if (validateIfNecessary()) { |
| if (r < 0 || r >= getAccessibleRowCount() || |
| c < 0 || c >= getAccessibleColumnCount()) { |
| return false; |
| } |
| TableCellElementInfo cell = getCell(r, c); |
| if (cell != null) { |
| Element elem = cell.getElement(); |
| int start = elem.getStartOffset(); |
| int end = elem.getEndOffset(); |
| return start >= editor.getSelectionStart() && |
| end <= editor.getSelectionEnd(); |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the specified row |
| * is selected. |
| * |
| * @param r zero-based row of the table |
| * @return the boolean value true if the specified row is selected. |
| * Otherwise, false. |
| */ |
| public boolean isAccessibleRowSelected(int r) { |
| if (validateIfNecessary()) { |
| if (r < 0 || r >= getAccessibleRowCount()) { |
| return false; |
| } |
| int nColumns = getAccessibleColumnCount(); |
| |
| TableCellElementInfo startCell = getCell(r, 0); |
| if (startCell == null) { |
| return false; |
| } |
| int start = startCell.getElement().getStartOffset(); |
| |
| TableCellElementInfo endCell = getCell(r, nColumns-1); |
| if (endCell == null) { |
| return false; |
| } |
| int end = endCell.getElement().getEndOffset(); |
| |
| return start >= editor.getSelectionStart() && |
| end <= editor.getSelectionEnd(); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the specified column |
| * is selected. |
| * |
| * @param c zero-based column of the table |
| * @return the boolean value true if the specified column is selected. |
| * Otherwise, false. |
| */ |
| public boolean isAccessibleColumnSelected(int c) { |
| if (validateIfNecessary()) { |
| if (c < 0 || c >= getAccessibleColumnCount()) { |
| return false; |
| } |
| int nRows = getAccessibleRowCount(); |
| |
| TableCellElementInfo startCell = getCell(0, c); |
| if (startCell == null) { |
| return false; |
| } |
| int start = startCell.getElement().getStartOffset(); |
| |
| TableCellElementInfo endCell = getCell(nRows-1, c); |
| if (endCell == null) { |
| return false; |
| } |
| int end = endCell.getElement().getEndOffset(); |
| return start >= editor.getSelectionStart() && |
| end <= editor.getSelectionEnd(); |
| } |
| return false; |
| } |
| |
| /** |
| * Returns the selected rows in a table. |
| * |
| * @return an array of selected rows where each element is a |
| * zero-based row of the table |
| */ |
| public int [] getSelectedAccessibleRows() { |
| if (validateIfNecessary()) { |
| int nRows = getAccessibleRowCount(); |
| Vector<Integer> vec = new Vector<Integer>(); |
| |
| for (int i = 0; i < nRows; i++) { |
| if (isAccessibleRowSelected(i)) { |
| vec.addElement(Integer.valueOf(i)); |
| } |
| } |
| int retval[] = new int[vec.size()]; |
| for (int i = 0; i < retval.length; i++) { |
| retval[i] = vec.elementAt(i).intValue(); |
| } |
| return retval; |
| } |
| return new int[0]; |
| } |
| |
| /** |
| * Returns the selected columns in a table. |
| * |
| * @return an array of selected columns where each element is a |
| * zero-based column of the table |
| */ |
| public int [] getSelectedAccessibleColumns() { |
| if (validateIfNecessary()) { |
| int nColumns = getAccessibleRowCount(); |
| Vector<Integer> vec = new Vector<Integer>(); |
| |
| for (int i = 0; i < nColumns; i++) { |
| if (isAccessibleColumnSelected(i)) { |
| vec.addElement(Integer.valueOf(i)); |
| } |
| } |
| int retval[] = new int[vec.size()]; |
| for (int i = 0; i < retval.length; i++) { |
| retval[i] = vec.elementAt(i).intValue(); |
| } |
| return retval; |
| } |
| return new int[0]; |
| } |
| |
| // begin AccessibleExtendedTable implementation ------------- |
| |
| /** |
| * Returns the row number of an index in the table. |
| * |
| * @param index the zero-based index in the table |
| * @return the zero-based row of the table if one exists; |
| * otherwise -1. |
| */ |
| public int getAccessibleRow(int index) { |
| if (validateIfNecessary()) { |
| int numCells = getAccessibleColumnCount() * |
| getAccessibleRowCount(); |
| if (index >= numCells) { |
| return -1; |
| } else { |
| return index / getAccessibleColumnCount(); |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns the column number of an index in the table. |
| * |
| * @param index the zero-based index in the table |
| * @return the zero-based column of the table if one exists; |
| * otherwise -1. |
| */ |
| public int getAccessibleColumn(int index) { |
| if (validateIfNecessary()) { |
| int numCells = getAccessibleColumnCount() * |
| getAccessibleRowCount(); |
| if (index >= numCells) { |
| return -1; |
| } else { |
| return index % getAccessibleColumnCount(); |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns the index at a row and column in the table. |
| * |
| * @param r zero-based row of the table |
| * @param c zero-based column of the table |
| * @return the zero-based index in the table if one exists; |
| * otherwise -1. |
| */ |
| public int getAccessibleIndex(int r, int c) { |
| if (validateIfNecessary()) { |
| if (r >= getAccessibleRowCount() || |
| c >= getAccessibleColumnCount()) { |
| return -1; |
| } else { |
| return r * getAccessibleColumnCount() + c; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns the row header at a row in a table. |
| * @param r zero-based row of the table |
| * |
| * @return a String representing the row header |
| * if one exists; otherwise null. |
| */ |
| public String getAccessibleRowHeader(int r) { |
| if (validateIfNecessary()) { |
| TableCellElementInfo cellInfo = getCell(r, 0); |
| if (cellInfo.isHeaderCell()) { |
| View v = cellInfo.getView(); |
| if (v != null && model != null) { |
| try { |
| return model.getText(v.getStartOffset(), |
| v.getEndOffset() - |
| v.getStartOffset()); |
| } catch (BadLocationException e) { |
| return null; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the column header at a column in a table. |
| * @param c zero-based column of the table |
| * |
| * @return a String representing the column header |
| * if one exists; otherwise null. |
| */ |
| public String getAccessibleColumnHeader(int c) { |
| if (validateIfNecessary()) { |
| TableCellElementInfo cellInfo = getCell(0, c); |
| if (cellInfo.isHeaderCell()) { |
| View v = cellInfo.getView(); |
| if (v != null && model != null) { |
| try { |
| return model.getText(v.getStartOffset(), |
| v.getEndOffset() - |
| v.getStartOffset()); |
| } catch (BadLocationException e) { |
| return null; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| public void addRowHeader(TableCellElementInfo cellInfo, int rowNumber) { |
| if (rowHeadersTable == null) { |
| rowHeadersTable = new AccessibleHeadersTable(); |
| } |
| rowHeadersTable.addHeader(cellInfo, rowNumber); |
| } |
| // end of AccessibleExtendedTable implementation ------------ |
| |
| protected class AccessibleHeadersTable implements AccessibleTable { |
| |
| // Header information is modeled as a Hashtable of |
| // ArrayLists where each Hashtable entry represents |
| // a row containing one or more headers. |
| private Hashtable<Integer, ArrayList<TableCellElementInfo>> headers = |
| new Hashtable<Integer, ArrayList<TableCellElementInfo>>(); |
| private int rowCount = 0; |
| private int columnCount = 0; |
| |
| public void addHeader(TableCellElementInfo cellInfo, int rowNumber) { |
| Integer rowInteger = Integer.valueOf(rowNumber); |
| ArrayList<TableCellElementInfo> list = headers.get(rowInteger); |
| if (list == null) { |
| list = new ArrayList<TableCellElementInfo>(); |
| headers.put(rowInteger, list); |
| } |
| list.add(cellInfo); |
| } |
| |
| /** |
| * Returns the caption for the table. |
| * |
| * @return the caption for the table |
| */ |
| public Accessible getAccessibleCaption() { |
| return null; |
| } |
| |
| /** |
| * Sets the caption for the table. |
| * |
| * @param a the caption for the table |
| */ |
| public void setAccessibleCaption(Accessible a) { |
| } |
| |
| /** |
| * Returns the summary description of the table. |
| * |
| * @return the summary description of the table |
| */ |
| public Accessible getAccessibleSummary() { |
| return null; |
| } |
| |
| /** |
| * Sets the summary description of the table |
| * |
| * @param a the summary description of the table |
| */ |
| public void setAccessibleSummary(Accessible a) { |
| } |
| |
| /** |
| * Returns the number of rows in the table. |
| * |
| * @return the number of rows in the table |
| */ |
| public int getAccessibleRowCount() { |
| return rowCount; |
| } |
| |
| /** |
| * Returns the number of columns in the table. |
| * |
| * @return the number of columns in the table |
| */ |
| public int getAccessibleColumnCount() { |
| return columnCount; |
| } |
| |
| private TableCellElementInfo getElementInfoAt(int r, int c) { |
| ArrayList<TableCellElementInfo> list = headers.get(Integer.valueOf(r)); |
| if (list != null) { |
| return list.get(c); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the Accessible at a specified row and column |
| * in the table. |
| * |
| * @param r zero-based row of the table |
| * @param c zero-based column of the table |
| * @return the Accessible at the specified row and column |
| */ |
| public Accessible getAccessibleAt(int r, int c) { |
| ElementInfo elementInfo = getElementInfoAt(r, c); |
| if (elementInfo instanceof Accessible) { |
| return (Accessible)elementInfo; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the number of rows occupied by the Accessible at |
| * a specified row and column in the table. |
| * |
| * @return the number of rows occupied by the Accessible at a |
| * given specified (row, column) |
| */ |
| public int getAccessibleRowExtentAt(int r, int c) { |
| TableCellElementInfo elementInfo = getElementInfoAt(r, c); |
| if (elementInfo != null) { |
| return elementInfo.getRowCount(); |
| } else { |
| return 0; |
| } |
| } |
| |
| /** |
| * Returns the number of columns occupied by the Accessible at |
| * a specified row and column in the table. |
| * |
| * @return the number of columns occupied by the Accessible at a |
| * given specified row and column |
| */ |
| public int getAccessibleColumnExtentAt(int r, int c) { |
| TableCellElementInfo elementInfo = getElementInfoAt(r, c); |
| if (elementInfo != null) { |
| return elementInfo.getRowCount(); |
| } else { |
| return 0; |
| } |
| } |
| |
| /** |
| * Returns the row headers as an AccessibleTable. |
| * |
| * @return an AccessibleTable representing the row |
| * headers |
| */ |
| public AccessibleTable getAccessibleRowHeader() { |
| return null; |
| } |
| |
| /** |
| * Sets the row headers. |
| * |
| * @param table an AccessibleTable representing the |
| * row headers |
| */ |
| public void setAccessibleRowHeader(AccessibleTable table) { |
| } |
| |
| /** |
| * Returns the column headers as an AccessibleTable. |
| * |
| * @return an AccessibleTable representing the column |
| * headers |
| */ |
| public AccessibleTable getAccessibleColumnHeader() { |
| return null; |
| } |
| |
| /** |
| * Sets the column headers. |
| * |
| * @param table an AccessibleTable representing the |
| * column headers |
| */ |
| public void setAccessibleColumnHeader(AccessibleTable table) { |
| } |
| |
| /** |
| * Returns the description of the specified row in the table. |
| * |
| * @param r zero-based row of the table |
| * @return the description of the row |
| */ |
| public Accessible getAccessibleRowDescription(int r) { |
| return null; |
| } |
| |
| /** |
| * Sets the description text of the specified row of the table. |
| * |
| * @param r zero-based row of the table |
| * @param a the description of the row |
| */ |
| public void setAccessibleRowDescription(int r, Accessible a) { |
| } |
| |
| /** |
| * Returns the description text of the specified column in the table. |
| * |
| * @param c zero-based column of the table |
| * @return the text description of the column |
| */ |
| public Accessible getAccessibleColumnDescription(int c) { |
| return null; |
| } |
| |
| /** |
| * Sets the description text of the specified column in the table. |
| * |
| * @param c zero-based column of the table |
| * @param a the text description of the column |
| */ |
| public void setAccessibleColumnDescription(int c, Accessible a) { |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the accessible at |
| * a specified row and column is selected. |
| * |
| * @param r zero-based row of the table |
| * @param c zero-based column of the table |
| * @return the boolean value true if the accessible at the |
| * row and column is selected. Otherwise, the boolean value |
| * false |
| */ |
| public boolean isAccessibleSelected(int r, int c) { |
| return false; |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the specified row |
| * is selected. |
| * |
| * @param r zero-based row of the table |
| * @return the boolean value true if the specified row is selected. |
| * Otherwise, false. |
| */ |
| public boolean isAccessibleRowSelected(int r) { |
| return false; |
| } |
| |
| /** |
| * Returns a boolean value indicating whether the specified column |
| * is selected. |
| * |
| * @param c zero-based column of the table |
| * @return the boolean value true if the specified column is selected. |
| * Otherwise, false. |
| */ |
| public boolean isAccessibleColumnSelected(int c) { |
| return false; |
| } |
| |
| /** |
| * Returns the selected rows in a table. |
| * |
| * @return an array of selected rows where each element is a |
| * zero-based row of the table |
| */ |
| public int [] getSelectedAccessibleRows() { |
| return new int [0]; |
| } |
| |
| /** |
| * Returns the selected columns in a table. |
| * |
| * @return an array of selected columns where each element is a |
| * zero-based column of the table |
| */ |
| public int [] getSelectedAccessibleColumns() { |
| return new int [0]; |
| } |
| } |
| } // ... end AccessibleHeadersTable |
| |
| /* |
| * ElementInfo for table rows |
| */ |
| private class TableRowElementInfo extends ElementInfo { |
| |
| private TableElementInfo parent; |
| private int rowNumber; |
| |
| TableRowElementInfo(Element e, TableElementInfo parent, int rowNumber) { |
| super(e, parent); |
| this.parent = parent; |
| this.rowNumber = rowNumber; |
| } |
| |
| protected void loadChildren(Element e) { |
| for (int x = 0; x < e.getElementCount(); x++) { |
| AttributeSet attrs = e.getElement(x).getAttributes(); |
| |
| if (attrs.getAttribute(StyleConstants.NameAttribute) == |
| HTML.Tag.TH) { |
| TableCellElementInfo headerElementInfo = |
| new TableCellElementInfo(e.getElement(x), this, true); |
| addChild(headerElementInfo); |
| |
| AccessibleTable at = |
| parent.getAccessibleContext().getAccessibleTable(); |
| TableAccessibleContext tableElement = |
| (TableAccessibleContext)at; |
| tableElement.addRowHeader(headerElementInfo, rowNumber); |
| |
| } else if (attrs.getAttribute(StyleConstants.NameAttribute) == |
| HTML.Tag.TD) { |
| addChild(new TableCellElementInfo(e.getElement(x), this, |
| false)); |
| } |
| } |
| } |
| |
| /** |
| * Returns the max of the rowspans of the cells in this row. |
| */ |
| public int getRowCount() { |
| int rowCount = 1; |
| if (validateIfNecessary()) { |
| for (int counter = 0; counter < getChildCount(); |
| counter++) { |
| |
| TableCellElementInfo cell = (TableCellElementInfo) |
| getChild(counter); |
| |
| if (cell.validateIfNecessary()) { |
| rowCount = Math.max(rowCount, cell.getRowCount()); |
| } |
| } |
| } |
| return rowCount; |
| } |
| |
| /** |
| * Returns the sum of the column spans of the individual |
| * cells in this row. |
| */ |
| public int getColumnCount() { |
| int colCount = 0; |
| if (validateIfNecessary()) { |
| for (int counter = 0; counter < getChildCount(); |
| counter++) { |
| TableCellElementInfo cell = (TableCellElementInfo) |
| getChild(counter); |
| |
| if (cell.validateIfNecessary()) { |
| colCount += cell.getColumnCount(); |
| } |
| } |
| } |
| return colCount; |
| } |
| |
| /** |
| * Overriden to invalidate the table as well as |
| * TableRowElementInfo. |
| */ |
| protected void invalidate(boolean first) { |
| super.invalidate(first); |
| getParent().invalidate(true); |
| } |
| |
| /** |
| * Places the TableCellElementInfos for this element in |
| * the grid. |
| */ |
| private void updateGrid(int row) { |
| if (validateIfNecessary()) { |
| boolean emptyRow = false; |
| |
| while (!emptyRow) { |
| for (int counter = 0; counter < grid[row].length; |
| counter++) { |
| if (grid[row][counter] == null) { |
| emptyRow = true; |
| break; |
| } |
| } |
| if (!emptyRow) { |
| row++; |
| } |
| } |
| for (int col = 0, counter = 0; counter < getChildCount(); |
| counter++) { |
| TableCellElementInfo cell = (TableCellElementInfo) |
| getChild(counter); |
| |
| while (grid[row][col] != null) { |
| col++; |
| } |
| for (int rowCount = cell.getRowCount() - 1; |
| rowCount >= 0; rowCount--) { |
| for (int colCount = cell.getColumnCount() - 1; |
| colCount >= 0; colCount--) { |
| grid[row + rowCount][col + colCount] = cell; |
| } |
| } |
| col += cell.getColumnCount(); |
| } |
| } |
| } |
| |
| /** |
| * Returns the column count of the number of columns that have |
| * a rowcount >= rowspan. |
| */ |
| private int getColumnCount(int rowspan) { |
| if (validateIfNecessary()) { |
| int cols = 0; |
| for (int counter = 0; counter < getChildCount(); |
| counter++) { |
| TableCellElementInfo cell = (TableCellElementInfo) |
| getChild(counter); |
| |
| if (cell.getRowCount() >= rowspan) { |
| cols += cell.getColumnCount(); |
| } |
| } |
| return cols; |
| } |
| return 0; |
| } |
| } |
| |
| /** |
| * TableCellElementInfo is used to represents the cells of |
| * the table. |
| */ |
| private class TableCellElementInfo extends ElementInfo { |
| |
| private Accessible accessible; |
| private boolean isHeaderCell; |
| |
| TableCellElementInfo(Element e, ElementInfo parent) { |
| super(e, parent); |
| this.isHeaderCell = false; |
| } |
| |
| TableCellElementInfo(Element e, ElementInfo parent, |
| boolean isHeaderCell) { |
| super(e, parent); |
| this.isHeaderCell = isHeaderCell; |
| } |
| |
| /* |
| * Returns whether this table cell is a header |
| */ |
| public boolean isHeaderCell() { |
| return this.isHeaderCell; |
| } |
| |
| /* |
| * Returns the Accessible representing this table cell |
| */ |
| public Accessible getAccessible() { |
| accessible = null; |
| getAccessible(this); |
| return accessible; |
| } |
| |
| /* |
| * Gets the outermost Accessible in the table cell |
| */ |
| private void getAccessible(ElementInfo elementInfo) { |
| if (elementInfo instanceof Accessible) { |
| accessible = (Accessible)elementInfo; |
| } else { |
| for (int i = 0; i < elementInfo.getChildCount(); i++) { |
| getAccessible(elementInfo.getChild(i)); |
| } |
| } |
| } |
| |
| /** |
| * Returns the rowspan attribute. |
| */ |
| public int getRowCount() { |
| if (validateIfNecessary()) { |
| return Math.max(1, getIntAttr(getAttributes(), |
| HTML.Attribute.ROWSPAN, 1)); |
| } |
| return 0; |
| } |
| |
| /** |
| * Returns the colspan attribute. |
| */ |
| public int getColumnCount() { |
| if (validateIfNecessary()) { |
| return Math.max(1, getIntAttr(getAttributes(), |
| HTML.Attribute.COLSPAN, 1)); |
| } |
| return 0; |
| } |
| |
| /** |
| * Overriden to invalidate the TableRowElementInfo as well as |
| * the TableCellElementInfo. |
| */ |
| protected void invalidate(boolean first) { |
| super.invalidate(first); |
| getParent().invalidate(true); |
| } |
| } |
| } |
| |
| |
| /** |
| * ElementInfo provides a slim down view of an Element. Each ElementInfo |
| * can have any number of child ElementInfos that are not necessarily |
| * direct children of the Element. As the Document changes various |
| * ElementInfos become invalidated. Before accessing a particular portion |
| * of an ElementInfo you should make sure it is valid by invoking |
| * <code>validateIfNecessary</code>, this will return true if |
| * successful, on the other hand a false return value indicates the |
| * ElementInfo is not valid and can never become valid again (usually |
| * the result of the Element the ElementInfo encapsulates being removed). |
| */ |
| private class ElementInfo { |
| |
| /** |
| * The children of this ElementInfo. |
| */ |
| private ArrayList<ElementInfo> children; |
| /** |
| * The Element this ElementInfo is providing information for. |
| */ |
| private Element element; |
| /** |
| * The parent ElementInfo, will be null for the root. |
| */ |
| private ElementInfo parent; |
| /** |
| * Indicates the validity of the ElementInfo. |
| */ |
| private boolean isValid; |
| /** |
| * Indicates if the ElementInfo can become valid. |
| */ |
| private boolean canBeValid; |
| |
| |
| /** |
| * Creates the root ElementInfo. |
| */ |
| ElementInfo(Element element) { |
| this(element, null); |
| } |
| |
| /** |
| * Creates an ElementInfo representing <code>element</code> with |
| * the specified parent. |
| */ |
| ElementInfo(Element element, ElementInfo parent) { |
| this.element = element; |
| this.parent = parent; |
| isValid = false; |
| canBeValid = true; |
| } |
| |
| /** |
| * Validates the receiver. This recreates the children as well. This |
| * will be invoked within a <code>readLock</code>. If this is overriden |
| * it MUST invoke supers implementation first! |
| */ |
| protected void validate() { |
| isValid = true; |
| loadChildren(getElement()); |
| } |
| |
| /** |
| * Recreates the direct children of <code>info</code>. |
| */ |
| protected void loadChildren(Element parent) { |
| if (!parent.isLeaf()) { |
| for (int counter = 0, maxCounter = parent.getElementCount(); |
| counter < maxCounter; counter++) { |
| Element e = parent.getElement(counter); |
| ElementInfo childInfo = createElementInfo(e, this); |
| |
| if (childInfo != null) { |
| addChild(childInfo); |
| } |
| else { |
| loadChildren(e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the index of the child in the parent, or -1 for the |
| * root or if the parent isn't valid. |
| */ |
| public int getIndexInParent() { |
| if (parent == null || !parent.isValid()) { |
| return -1; |
| } |
| return parent.indexOf(this); |
| } |
| |
| /** |
| * Returns the Element this <code>ElementInfo</code> represents. |
| */ |
| public Element getElement() { |
| return element; |
| } |
| |
| /** |
| * Returns the parent of this Element, or null for the root. |
| */ |
| public ElementInfo getParent() { |
| return parent; |
| } |
| |
| /** |
| * Returns the index of the specified child, or -1 if |
| * <code>child</code> isn't a valid child. |
| */ |
| public int indexOf(ElementInfo child) { |
| ArrayList<ElementInfo> children = this.children; |
| |
| if (children != null) { |
| return children.indexOf(child); |
| } |
| return -1; |
| } |
| |
| /** |
| * Returns the child ElementInfo at <code>index</code>, or null |
| * if <code>index</code> isn't a valid index. |
| */ |
| public ElementInfo getChild(int index) { |
| if (validateIfNecessary()) { |
| ArrayList<ElementInfo> children = this.children; |
| |
| if (children != null && index >= 0 && |
| index < children.size()) { |
| return children.get(index); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the number of children the ElementInfo contains. |
| */ |
| public int getChildCount() { |
| validateIfNecessary(); |
| return (children == null) ? 0 : children.size(); |
| } |
| |
| /** |
| * Adds a new child to this ElementInfo. |
| */ |
| protected void addChild(ElementInfo child) { |
| if (children == null) { |
| children = new ArrayList<ElementInfo>(); |
| } |
| children.add(child); |
| } |
| |
| /** |
| * Returns the View corresponding to this ElementInfo, or null |
| * if the ElementInfo can't be validated. |
| */ |
| protected View getView() { |
| if (!validateIfNecessary()) { |
| return null; |
| } |
| Object lock = lock(); |
| try { |
| View rootView = getRootView(); |
| Element e = getElement(); |
| int start = e.getStartOffset(); |
| |
| if (rootView != null) { |
| return getView(rootView, e, start); |
| } |
| return null; |
| } finally { |
| unlock(lock); |
| } |
| } |
| |
| /** |
| * Returns the Bounds for this ElementInfo, or null |
| * if the ElementInfo can't be validated. |
| */ |
| public Rectangle getBounds() { |
| if (!validateIfNecessary()) { |
| return null; |
| } |
| Object lock = lock(); |
| try { |
| Rectangle bounds = getRootEditorRect(); |
| View rootView = getRootView(); |
| Element e = getElement(); |
| |
| if (bounds != null && rootView != null) { |
| try { |
| return rootView.modelToView(e.getStartOffset(), |
| Position.Bias.Forward, |
| e.getEndOffset(), |
| Position.Bias.Backward, |
| bounds).getBounds(); |
| } catch (BadLocationException ble) { } |
| } |
| } finally { |
| unlock(lock); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns true if this ElementInfo is valid. |
| */ |
| protected boolean isValid() { |
| return isValid; |
| } |
| |
| /** |
| * Returns the AttributeSet associated with the Element, this will |
| * return null if the ElementInfo can't be validated. |
| */ |
| protected AttributeSet getAttributes() { |
| if (validateIfNecessary()) { |
| return getElement().getAttributes(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the AttributeSet associated with the View that is |
| * representing this Element, this will |
| * return null if the ElementInfo can't be validated. |
| */ |
| protected AttributeSet getViewAttributes() { |
| if (validateIfNecessary()) { |
| View view = getView(); |
| |
| if (view != null) { |
| return view.getElement().getAttributes(); |
| } |
| return getElement().getAttributes(); |
| } |
| return null; |
| } |
| |
| /** |
| * Convenience method for getting an integer attribute from the passed |
| * in AttributeSet. |
| */ |
| protected int getIntAttr(AttributeSet attrs, Object key, int deflt) { |
| if (attrs != null && attrs.isDefined(key)) { |
| int i; |
| String val = (String)attrs.getAttribute(key); |
| if (val == null) { |
| i = deflt; |
| } |
| else { |
| try { |
| i = Math.max(0, Integer.parseInt(val)); |
| } catch (NumberFormatException x) { |
| i = deflt; |
| } |
| } |
| return i; |
| } |
| return deflt; |
| } |
| |
| /** |
| * Validates the ElementInfo if necessary. Some ElementInfos may |
| * never be valid again. You should check <code>isValid</code> before |
| * using one. This will reload the children and invoke |
| * <code>validate</code> if the ElementInfo is invalid and can become |
| * valid again. This will return true if the receiver is valid. |
| */ |
| protected boolean validateIfNecessary() { |
| if (!isValid() && canBeValid) { |
| children = null; |
| Object lock = lock(); |
| |
| try { |
| validate(); |
| } finally { |
| unlock(lock); |
| } |
| } |
| return isValid(); |
| } |
| |
| /** |
| * Invalidates the ElementInfo. Subclasses should override this |
| * if they need to reset state once invalid. |
| */ |
| protected void invalidate(boolean first) { |
| if (!isValid()) { |
| if (canBeValid && !first) { |
| canBeValid = false; |
| } |
| return; |
| } |
| isValid = false; |
| canBeValid = first; |
| if (children != null) { |
| for (ElementInfo child : children) { |
| child.invalidate(false); |
| } |
| children = null; |
| } |
| } |
| |
| private View getView(View parent, Element e, int start) { |
| if (parent.getElement() == e) { |
| return parent; |
| } |
| int index = parent.getViewIndex(start, Position.Bias.Forward); |
| |
| if (index != -1 && index < parent.getViewCount()) { |
| return getView(parent.getView(index), e, start); |
| } |
| return null; |
| } |
| |
| private int getClosestInfoIndex(int index) { |
| for (int counter = 0; counter < getChildCount(); counter++) { |
| ElementInfo info = getChild(counter); |
| |
| if (index < info.getElement().getEndOffset() || |
| index == info.getElement().getStartOffset()) { |
| return counter; |
| } |
| } |
| return -1; |
| } |
| |
| private void update(DocumentEvent e) { |
| if (!isValid()) { |
| return; |
| } |
| ElementInfo parent = getParent(); |
| Element element = getElement(); |
| |
| do { |
| DocumentEvent.ElementChange ec = e.getChange(element); |
| if (ec != null) { |
| if (element == getElement()) { |
| // One of our children changed. |
| invalidate(true); |
| } |
| else if (parent != null) { |
| parent.invalidate(parent == getRootInfo()); |
| } |
| return; |
| } |
| element = element.getParentElement(); |
| } while (parent != null && element != null && |
| element != parent.getElement()); |
| |
| if (getChildCount() > 0) { |
| Element elem = getElement(); |
| int pos = e.getOffset(); |
| int index0 = getClosestInfoIndex(pos); |
| if (index0 == -1 && |
| e.getType() == DocumentEvent.EventType.REMOVE && |
| pos >= elem.getEndOffset()) { |
| // Event beyond our offsets. We may have represented this, |
| // that is the remove may have removed one of our child |
| // Elements that represented this, so, we should foward |
| // to last element. |
| index0 = getChildCount() - 1; |
| } |
| ElementInfo info = (index0 >= 0) ? getChild(index0) : null; |
| if (info != null && |
| (info.getElement().getStartOffset() == pos) && (pos > 0)) { |
| // If at a boundary, forward the event to the previous |
| // ElementInfo too. |
| index0 = Math.max(index0 - 1, 0); |
| } |
| int index1; |
| if (e.getType() != DocumentEvent.EventType.REMOVE) { |
| index1 = getClosestInfoIndex(pos + e.getLength()); |
| if (index1 < 0) { |
| index1 = getChildCount() - 1; |
| } |
| } |
| else { |
| index1 = index0; |
| // A remove may result in empty elements. |
| while ((index1 + 1) < getChildCount() && |
| getChild(index1 + 1).getElement().getEndOffset() == |
| getChild(index1 + 1).getElement().getStartOffset()){ |
| index1++; |
| } |
| } |
| index0 = Math.max(index0, 0); |
| // The check for isValid is here as in the process of |
| // forwarding update our child may invalidate us. |
| for (int i = index0; i <= index1 && isValid(); i++) { |
| getChild(i).update(e); |
| } |
| } |
| } |
| } |
| |
| /** |
| * DocumentListener installed on the current Document. Will invoke |
| * <code>update</code> on the <code>RootInfo</code> in response to |
| * any event. |
| */ |
| private class DocumentHandler implements DocumentListener { |
| public void insertUpdate(DocumentEvent e) { |
| getRootInfo().update(e); |
| } |
| public void removeUpdate(DocumentEvent e) { |
| getRootInfo().update(e); |
| } |
| public void changedUpdate(DocumentEvent e) { |
| getRootInfo().update(e); |
| } |
| } |
| |
| /* |
| * PropertyChangeListener installed on the editor. |
| */ |
| private class PropertyChangeHandler implements PropertyChangeListener { |
| public void propertyChange(PropertyChangeEvent evt) { |
| if (evt.getPropertyName().equals("document")) { |
| // handle the document change |
| setDocument(editor.getDocument()); |
| } |
| } |
| } |
| } |