From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/classpath/javax/swing/FocusManager.java | 524 ++++++++++++++++++++++++ 1 file changed, 524 insertions(+) create mode 100644 libjava/classpath/javax/swing/FocusManager.java (limited to 'libjava/classpath/javax/swing/FocusManager.java') diff --git a/libjava/classpath/javax/swing/FocusManager.java b/libjava/classpath/javax/swing/FocusManager.java new file mode 100644 index 000000000..b8459d4d5 --- /dev/null +++ b/libjava/classpath/javax/swing/FocusManager.java @@ -0,0 +1,524 @@ +/* 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 true if the event has been dispatched, + * false otherwise + */ + public boolean dispatchEvent(AWTEvent ev) + { + return wrapped.dispatchEvent(ev); + } + + /** + * Wraps {@link DefaultKeyboardFocusManager#dispatchKeyEvent(KeyEvent)}. + * + * @param ev the event to dispatch + * + * @return true if the event has been dispatched, + * false 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 + } +} -- cgit v1.2.3