| /* FocusManager.java -- |
| Copyright (C) 2002, 2004 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.AWTEvent; |
| import java.awt.Component; |
| import java.awt.Container; |
| import java.awt.DefaultKeyboardFocusManager; |
| import java.awt.FocusTraversalPolicy; |
| import java.awt.KeyEventDispatcher; |
| import java.awt.KeyEventPostProcessor; |
| import java.awt.KeyboardFocusManager; |
| import java.awt.Window; |
| import java.awt.event.KeyEvent; |
| import java.beans.PropertyChangeListener; |
| import java.beans.VetoableChangeListener; |
| import java.util.Set; |
| |
| /** |
| * This class has been obsoleted by the new |
| * {@link java.awt.KeyboardFocusManager} and |
| * {@link java.awt.DefaultKeyboardFocusManager} API. |
| * |
| * @author Andrew Selkirk |
| */ |
| public abstract class FocusManager |
| extends DefaultKeyboardFocusManager |
| { |
| /** |
| * A FocusManager that wraps an AWT KeyboardFocusManager and forwards all |
| * method calls to it. This is used for compatibility with the new focus |
| * system. |
| * |
| * @author Roman Kennke (kennke@aicas.com) |
| */ |
| private static class WrappingFocusManager |
| extends FocusManager |
| { |
| /** |
| * The wrapped KeyboardFocusManager. |
| */ |
| private KeyboardFocusManager wrapped; |
| |
| /** |
| * Creates a new instance of WrappedFocusManager. |
| * |
| * @param fm the focus manager to wrap |
| */ |
| WrappingFocusManager(KeyboardFocusManager fm) |
| { |
| wrapped = fm; |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#dispatchEvent(AWTEvent)}. |
| * |
| * @param ev the event to dispatch |
| * |
| * @return <code>true</code> if the event has been dispatched, |
| * <code>false</code> otherwise |
| */ |
| public boolean dispatchEvent(AWTEvent ev) |
| { |
| return wrapped.dispatchEvent(ev); |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#dispatchKeyEvent(KeyEvent)}. |
| * |
| * @param ev the event to dispatch |
| * |
| * @return <code>true</code> if the event has been dispatched, |
| * <code>false</code> otherwise |
| */ |
| public boolean dispatchKeyEvent(KeyEvent ev) |
| { |
| return wrapped.dispatchKeyEvent(ev); |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#downFocusCycle(Container)}. |
| * |
| * @param c the container |
| */ |
| public void downFocusCycle(Container c) |
| { |
| wrapped.downFocusCycle(c); |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#upFocusCycle(Container)}. |
| * |
| * @param c the container |
| */ |
| public void upFocusCycle(Container c) |
| { |
| wrapped.upFocusCycle(c); |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#focusNextComponent(Component)}. |
| * |
| * @param c the component |
| */ |
| public void focusNextComponent(Component c) |
| { |
| wrapped.focusNextComponent(c); |
| } |
| |
| /** |
| * Wraps |
| * {@link DefaultKeyboardFocusManager#focusPreviousComponent(Component)}. |
| * |
| * @param c the component |
| */ |
| public void focusPreviousComponent(Component c) |
| { |
| wrapped.focusPreviousComponent(c); |
| } |
| |
| /** |
| * Wraps {@link DefaultKeyboardFocusManager#postProcessKeyEvent(KeyEvent)}. |
| * |
| * @param e the key event |
| * |
| * @return a boolead |
| */ |
| public boolean postProcessKeyEvent(KeyEvent e) |
| { |
| return wrapped.postProcessKeyEvent(e); |
| } |
| |
| /** |
| * Wraps |
| * {@link DefaultKeyboardFocusManager#processKeyEvent(Component, KeyEvent)}. |
| * |
| * @param c the component |
| * @param e the key event |
| */ |
| public void processKeyEvent(Component c, KeyEvent e) |
| { |
| wrapped.processKeyEvent(c, e); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#addKeyEventDispatcher(KeyEventDispatcher)}. |
| * |
| * @param d the dispatcher |
| */ |
| public void addKeyEventDispatcher(KeyEventDispatcher d) |
| { |
| wrapped.addKeyEventDispatcher(d); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#addKeyEventPostProcessor(KeyEventPostProcessor)}. |
| * |
| * @param p the post processor |
| */ |
| public void addKeyEventPostProcessor(KeyEventPostProcessor p) |
| { |
| wrapped.addKeyEventPostProcessor(p); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(PropertyChangeListener)}. |
| * |
| * @param l the property change listener |
| */ |
| public void addPropertyChangeListener(PropertyChangeListener l) |
| { |
| wrapped.addPropertyChangeListener(l); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(String, PropertyChangeListener)}. |
| * |
| * @param p the property name |
| * @param l the property change listener |
| */ |
| public void addPropertyChangeListener(String p, PropertyChangeListener l) |
| { |
| wrapped.addPropertyChangeListener(p, l); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(String, VetoableChangeListener)}. |
| * |
| * @param p the property name |
| * @param l the vetoable change listener |
| */ |
| public void addVetoableChangeListener(String p, VetoableChangeListener l) |
| { |
| wrapped.addVetoableChangeListener(p, l); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(VetoableChangeListener)}. |
| * |
| * @param l the vetoable change listener |
| */ |
| public void addVetoableChangeListener(VetoableChangeListener l) |
| { |
| wrapped.addVetoableChangeListener(l); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#clearGlobalFocusOwner()}. |
| */ |
| public void clearGlobalFocusOwner() |
| { |
| wrapped.clearGlobalFocusOwner(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getActiveWindow()}. |
| * |
| * @return the active window |
| */ |
| public Window getActiveWindow() |
| { |
| return wrapped.getActiveWindow(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getCurrentFocusCycleRoot()}. |
| * |
| * @return the focus cycle root |
| */ |
| public Container getCurrentFocusCycleRoot() |
| { |
| return wrapped.getCurrentFocusCycleRoot(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalKeys(int)}. |
| * |
| * @param i the ID |
| * |
| * @return the focus traversal keys |
| */ |
| public Set getDefaultFocusTraversalKeys(int i) |
| { |
| return wrapped.getDefaultFocusTraversalKeys(i); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalPolicy()}. |
| * |
| * @return the focus traversal policy |
| */ |
| public FocusTraversalPolicy getDefaultFocusTraversalPolicy() |
| { |
| return wrapped.getDefaultFocusTraversalPolicy(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getFocusedWindow()}. |
| * |
| * @return the focused window |
| */ |
| public Window getFocusedWindow() |
| { |
| return wrapped.getFocusedWindow(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getFocusOwner()}. |
| * |
| * @return the focus owner |
| */ |
| public Component getFocusOwner() |
| { |
| return wrapped.getFocusOwner(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getPermanentFocusOwner()}. |
| * |
| * @return the focus owner |
| */ |
| public Component getPermanentFocusOwner() |
| { |
| return wrapped.getPermanentFocusOwner(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners()}. |
| * |
| * @return the property change listeners |
| */ |
| public PropertyChangeListener[] getPropertyChangeListeners() |
| { |
| return wrapped.getPropertyChangeListeners(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners(String)}. |
| * |
| * @param n the property name |
| * |
| * @return the property change listeners |
| */ |
| public PropertyChangeListener[] getPropertyChangeListeners(String n) |
| { |
| return wrapped.getPropertyChangeListeners(n); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners()}. |
| * |
| * @return the vetoable change listeners |
| */ |
| public VetoableChangeListener[] getVetoableChangeListeners() |
| { |
| return wrapped.getVetoableChangeListeners(); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners(String)}. |
| * |
| * @param n the property name |
| * |
| * @return the vetoable change listeners |
| */ |
| public VetoableChangeListener[] getVetoableChangeListeners(String n) |
| { |
| return wrapped.getVetoableChangeListeners(n); |
| } |
| |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removeKeyEventDispatcher(KeyEventDispatcher)}. |
| * |
| * @param d the key event dispatcher to remove |
| */ |
| public void removeKeyEventDispatcher(KeyEventDispatcher d) |
| { |
| wrapped.removeKeyEventDispatcher(d); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removeKeyEventPostProcessor(KeyEventPostProcessor)}. |
| * |
| * @param p the post processor |
| */ |
| public void removeKeyEventPostProcessor(KeyEventPostProcessor p) |
| { |
| wrapped.removeKeyEventPostProcessor(p); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removePropertyChangeListener(PropertyChangeListener)}. |
| * |
| * @param l the listener |
| */ |
| public void removePropertyChangeListener(PropertyChangeListener l) |
| { |
| wrapped.removePropertyChangeListener(l); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removePropertyChangeListener(String, PropertyChangeListener)}. |
| * |
| * @param n the property name |
| * @param l the listener |
| */ |
| public void removePropertyChangeListener(String n, PropertyChangeListener l) |
| { |
| wrapped.removePropertyChangeListener(n, l); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removeVetoableChangeListener(VetoableChangeListener)}. |
| * |
| * @param l the listener |
| */ |
| public void removeVetoableChangeListener(VetoableChangeListener l) |
| { |
| wrapped.removeVetoableChangeListener(l); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#removeVetoableChangeListener(String, VetoableChangeListener)}. |
| * |
| * @param n the property name |
| * @param l the listener |
| */ |
| public void removeVetoableChangeListener(String n, VetoableChangeListener l) |
| { |
| wrapped.removeVetoableChangeListener(n, l); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#setDefaultFocusTraversalKeys(int, Set)}. |
| * |
| * @param id the ID |
| * @param k the keystrokes |
| */ |
| public void setDefaultFocusTraversalKeys(int id, Set k) |
| { |
| wrapped.setDefaultFocusTraversalKeys(id, k); |
| } |
| |
| /** |
| * Wraps {@link KeyboardFocusManager#setDefaultFocusTraversalPolicy(FocusTraversalPolicy)}. |
| * |
| * @param p the focus traversal policy |
| */ |
| public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy p) |
| { |
| wrapped.setDefaultFocusTraversalPolicy(p); |
| } |
| |
| /** |
| * Wraps |
| * {@link KeyboardFocusManager#setGlobalCurrentFocusCycleRoot(Container)}. |
| * |
| * @param r the focus cycle root |
| */ |
| public void setGlobalCurrentFocusCycleRoot(Container r) |
| { |
| wrapped.setGlobalCurrentFocusCycleRoot(r); |
| } |
| } |
| |
| /** |
| * FOCUS_MANAGER_CLASS_PROPERTY |
| */ |
| public static final String FOCUS_MANAGER_CLASS_PROPERTY = |
| "FocusManagerClassName"; |
| |
| /** |
| * Constructor FocusManager |
| */ |
| public FocusManager() |
| { |
| super(); |
| } |
| |
| /** |
| * getCurrentManager |
| * @return FocusManager |
| */ |
| public static FocusManager getCurrentManager() |
| { |
| KeyboardFocusManager m = |
| KeyboardFocusManager.getCurrentKeyboardFocusManager(); |
| return new WrappingFocusManager(m); |
| } |
| |
| /** |
| * setCurrentManager |
| * @param manager TODO |
| */ |
| public static void setCurrentManager(FocusManager manager) |
| { |
| KeyboardFocusManager.setCurrentKeyboardFocusManager(manager); |
| } |
| |
| /** |
| * disableSwingFocusManager |
| * @deprecated 1.4 |
| */ |
| public static void disableSwingFocusManager() |
| { |
| // TODO |
| } |
| |
| /** |
| * isFocusManagerEnabled |
| * @return boolean |
| * @deprecated 1.4 |
| */ |
| public static boolean isFocusManagerEnabled() |
| { |
| return false; // TODO |
| } |
| } |