This patch fixes some things in JComponent and Component: 1. yesterday I got confused regarding the handling of the opaque property wrt the accessibility method getAccessibleStateSet(). As it turns out, this property is _not_ handled at all in AccessibleAWTComponent, regardless of the value of the property. It's only handled by the AccessibleJComponent.getAccessibleStateSet(). Probably that is because only in JComponent this property is a kind of state that can change.
2. I implemented the remaining stubs in JComponent. These are all methods that are left over from obsolete/deprecated APIs and only there for compatibility. I implemented them using the newer APIs. For the set/getNextFocusableComponent() methods I introduced a new helper class, that maps this behaviour to a special FocusTraversPolicy. 2006-04-06 Roman Kennke <[EMAIL PROTECTED]> * java/awt/Component.java (AccessibleAWTComponent.getAccessibleStateSet): Don't handle opaque state here. This is only done in JComponent. * javax/swing/JComponent.java (AccessibleJComponent.getAccessibleStateSet): Handle opaque flag here. (getNextFocusableComponent): Implemented stub method. (grabFocus): Implemented stub method. (unregisterKeyboardAction): Implemented stub method. (setNextFocusableComponent): Implemented stub method. * javax/swing/CompatibilityFocusTraversalPolicy.java: New file. This is a helper class for providing compatibility with the older Swing focus API. /Roman
Index: java/awt/Component.java =================================================================== RCS file: /cvsroot/classpath/classpath/java/awt/Component.java,v retrieving revision 1.111 diff -u -1 -0 -r1.111 Component.java --- java/awt/Component.java 5 Apr 2006 10:31:26 -0000 1.111 +++ java/awt/Component.java 6 Apr 2006 10:10:00 -0000 @@ -5418,22 +5418,24 @@ */ public AccessibleStateSet getAccessibleStateSet() { AccessibleStateSet s = new AccessibleStateSet(); if (Component.this.isEnabled()) s.add(AccessibleState.ENABLED); if (isFocusable()) s.add(AccessibleState.FOCUSABLE); if (isFocusOwner()) s.add(AccessibleState.FOCUSED); - if (isOpaque()) - s.add(AccessibleState.OPAQUE); + // Note: While the java.awt.Component has an 'opaque' property, it + // seems that it is not added to the accessible state set here, even + // if this property is true. However, it is handled for + // javax.swing.JComponent, so we add it there. if (Component.this.isShowing()) s.add(AccessibleState.SHOWING); if (Component.this.isVisible()) s.add(AccessibleState.VISIBLE); return s; } /** * Returns the parent of this component, if it is accessible. * Index: javax/swing/JComponent.java =================================================================== RCS file: /cvsroot/classpath/classpath/javax/swing/JComponent.java,v retrieving revision 1.113 diff -u -1 -0 -r1.113 JComponent.java --- javax/swing/JComponent.java 5 Apr 2006 21:45:36 -0000 1.113 +++ javax/swing/JComponent.java 6 Apr 2006 10:10:00 -0000 @@ -330,24 +330,28 @@ return super.getAccessibleChild(i); } /** * Returns the accessible state set of this component. * * @return the accessible state set of this component */ public AccessibleStateSet getAccessibleStateSet() { - // TODO: The only JComponent property that is (theoretically) handled - // here seems to be 'opaque'. However, we already handle this in - // AccessibleAWTComponent and do not need to handle it here too. - return super.getAccessibleStateSet(); + // Note: While the java.awt.Component has an 'opaque' property, it + // seems that it is not added to the accessible state set there, even + // if this property is true. However, it is handled for JComponent, so + // we add it here. + AccessibleStateSet state = super.getAccessibleStateSet(); + if (isOpaque()) + state.add(AccessibleState.OPAQUE); + return state; } /** * Returns the localized name for this object. Generally this should * almost never return [EMAIL PROTECTED] Component#getName()} since that is not * a localized name. If the object is some kind of text component (like * a menu item), then the value of the object may be returned. Also, if * the object has a tooltip, the value of the tooltip may also be * appropriate. * @@ -1386,21 +1390,26 @@ /** * Return the value of the <code>nextFocusableComponent</code> property. * * @return The current value of the property, or <code>null</code> * if none has been set. * * @deprecated See [EMAIL PROTECTED] java.awt.FocusTraversalPolicy} */ public Component getNextFocusableComponent() { - return null; + Container focusRoot = this; + if (! this.isFocusCycleRoot()) + focusRoot = getFocusCycleRootAncestor(); + + FocusTraversalPolicy policy = focusRoot.getFocusTraversalPolicy(); + return policy.getComponentAfter(focusRoot, this); } /** * Return the set of [EMAIL PROTECTED] KeyStroke} objects which are registered * to initiate actions on this component. * * @return An array of the registered keystrokes */ public KeyStroke[] getRegisteredKeyStrokes() { @@ -1580,21 +1589,21 @@ * focus to the top level ancestor of this component. Only works on * displayable, focusable, visible components.</p> * * <p>This method should not be called by clients; it is intended for * focus implementations. Use [EMAIL PROTECTED] Component#requestFocus()} instead.</p> * * @see Component#requestFocus() */ public void grabFocus() { - // TODO: Implement this properly. + requestFocus(); } /** * Get the value of the [EMAIL PROTECTED] #doubleBuffered} property. * * @return The property's current value */ public boolean isDoubleBuffered() { return doubleBuffered; @@ -2568,21 +2577,34 @@ * Remove a keyboard action registry. * * @param aKeyStroke The keystroke to unregister * * @see #registerKeyboardAction(ActionListener, KeyStroke, int) * @see #getConditionForKeyStroke * @see #resetKeyboardActions */ public void unregisterKeyboardAction(KeyStroke aKeyStroke) { - // FIXME: Must be implemented. + ActionMap am = getActionMap(); + // This loops through the conditions WHEN_FOCUSED, + // WHEN_ANCESTOR_OF_FOCUSED_COMPONENT and WHEN_IN_FOCUSED_WINDOW. + for (int cond = 0; cond < 3; cond++) + { + InputMap im = getInputMap(cond); + if (im != null) + { + Object action = im.get(aKeyStroke); + if (action != null && am != null) + am.remove(action); + im.remove(aKeyStroke); + } + } } /** * Reset all keyboard action registries. * * @see #registerKeyboardAction(ActionListener, KeyStroke, int) * @see #unregisterKeyboardAction * @see #getConditionForKeyStroke */ @@ -2846,21 +2868,43 @@ * Set the specified component to be the next component in the * focus cycle, overriding the [EMAIL PROTECTED] FocusTraversalPolicy} for * this component. * * @param aComponent The component to set as the next focusable * * @deprecated Use FocusTraversalPolicy instead */ public void setNextFocusableComponent(Component aComponent) { - // TODO: Implement this properly. + Container focusRoot = this; + if (! this.isFocusCycleRoot()) + focusRoot = getFocusCycleRootAncestor(); + + FocusTraversalPolicy policy = focusRoot.getFocusTraversalPolicy(); + if (policy instanceof CompatibilityFocusTraversalPolicy) + { + policy = new CompatibilityFocusTraversalPolicy(policy); + focusRoot.setFocusTraversalPolicy(policy); + } + CompatibilityFocusTraversalPolicy p = + (CompatibilityFocusTraversalPolicy) policy; + + Component old = getNextFocusableComponent(); + if (old != null) + { + p.removeNextFocusableComponent(this, old); + } + + if (aComponent != null) + { + p.addNextFocusableComponent(this, aComponent); + } } /** * Set the value of the [EMAIL PROTECTED] #requestFocusEnabled} property. * * @param e The new value of the property */ public void setRequestFocusEnabled(boolean e) { requestFocusEnabled = e; Index: javax/swing/CompatibilityFocusTraversalPolicy.java =================================================================== RCS file: javax/swing/CompatibilityFocusTraversalPolicy.java diff -N javax/swing/CompatibilityFocusTraversalPolicy.java --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ javax/swing/CompatibilityFocusTraversalPolicy.java 6 Apr 2006 10:10:00 -0000 @@ -0,0 +1,164 @@ +/* CompatibilityFocusTraversalPolicy.java -- Provides compatibility to old + focus API + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package javax.swing; + +import java.awt.Component; +import java.awt.Container; +import java.awt.FocusTraversalPolicy; +import java.util.HashMap; + +/** + * Provides compatibility to the older focus API in + * [EMAIL PROTECTED] JComponent#setNextFocusableComponent(Component)}. + * + * @author Roman Kennke ([EMAIL PROTECTED]) + */ +class CompatibilityFocusTraversalPolicy + extends FocusTraversalPolicy +{ + + /** + * The focus traversal policy that has been installed on the focus cycle + * root before, and to which we fall back. + */ + private FocusTraversalPolicy fallback; + + /** + * Maps components to their next focused components. + */ + private HashMap forward; + + /** + * Maps components to their previous focused components. + */ + private HashMap backward; + + /** + * Creates a new CompatibilityFocusTraversalPolicy with the specified + * policy as fallback. + * + * @param p the fallback policy + */ + CompatibilityFocusTraversalPolicy(FocusTraversalPolicy p) + { + fallback = p; + forward = new HashMap(); + backward = new HashMap(); + } + + public Component getComponentAfter(Container root, Component current) + { + Component next = (Component) forward.get(current); + if (next == null && fallback != null) + next = fallback.getComponentAfter(root, current); + return next; + } + + public Component getComponentBefore(Container root, Component current) + { + Component previous = (Component) backward.get(current); + if (previous == null && fallback != null) + previous = fallback.getComponentAfter(root, current); + return previous; + } + + public Component getFirstComponent(Container root) + { + Component first = null; + if (fallback != null) + first = fallback.getFirstComponent(root); + return first; + } + + public Component getLastComponent(Container root) + { + Component last = null; + if (fallback != null) + last = fallback.getLastComponent(root); + return last; + } + + public Component getDefaultComponent(Container root) + { + Component def = null; + if (fallback != null) + def = fallback.getDefaultComponent(root); + return def; + } + + /** + * Sets a next focused component for a specified component. This is called + * by [EMAIL PROTECTED] JComponent#setNextFocusableComponent(Component)}. + * + * @param current the current component + * @param next the next focused component + */ + void setNextFocusableComponent(Component current, Component next) + { + forward.put(current, next); + backward.put(next, current); + } + + /** + * Sets a next focused component for a specified component. This is called + * by [EMAIL PROTECTED] JComponent#setNextFocusableComponent(Component)}. + * + * @param current the current component + * @param next the next focused component + */ + void addNextFocusableComponent(Component current, Component next) + { + forward.put(current, next); + backward.put(next, current); + } + + /** + * Removes a focused component mapping. This is called + * by [EMAIL PROTECTED] JComponent#setNextFocusableComponent(Component)}. + * + * @param current the current component + * @param next the next focused component + */ + void removeNextFocusableComponent(Component current, Component next) + { + forward.remove(current); + backward.remove(next); + } +}