001 /*
002 * Copyright 2001-2004 Sun Microsystems, Inc. All Rights Reserved.
003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004 *
005 * This code is free software; you can redistribute it and/or modify it
006 * under the terms of the GNU General Public License version 2 only, as
007 * published by the Free Software Foundation. Sun designates this
008 * particular file as subject to the "Classpath" exception as provided
009 * by Sun in the LICENSE file that accompanied this code.
010 *
011 * This code is distributed in the hope that it will be useful, but WITHOUT
012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014 * version 2 for more details (a copy is included in the LICENSE file that
015 * accompanied this code).
016 *
017 * You should have received a copy of the GNU General Public License version
018 * 2 along with this work; if not, write to the Free Software Foundation,
019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020 *
021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022 * CA 95054 USA or visit www.sun.com if you need additional information or
023 * have any questions.
024 */
025 package javax.swing;
026
027 import java.awt.*;
028 import java.awt.event.*;
029 import java.beans.*;
030 import java.util.Set;
031
032 /**
033 * Provides a javax.swing.DefaultFocusManager view onto an arbitrary
034 * java.awt.KeyboardFocusManager. We subclass DefaultFocusManager instead of
035 * FocusManager because it seems more backward-compatible. It is likely that
036 * some pre-1.4 code assumes that the object returned by
037 * FocusManager.getCurrentManager is an instance of DefaultFocusManager unless
038 * set explicitly.
039 */
040 final class DelegatingDefaultFocusManager extends DefaultFocusManager {
041 private final KeyboardFocusManager delegate;
042
043 DelegatingDefaultFocusManager(KeyboardFocusManager delegate) {
044 this .delegate = delegate;
045 setDefaultFocusTraversalPolicy(gluePolicy);
046 }
047
048 KeyboardFocusManager getDelegate() {
049 return delegate;
050 }
051
052 // Legacy methods which first appeared in javax.swing.FocusManager.
053 // Client code is most likely to invoke these methods.
054
055 public void processKeyEvent(Component focusedComponent, KeyEvent e) {
056 delegate.processKeyEvent(focusedComponent, e);
057 }
058
059 public void focusNextComponent(Component aComponent) {
060 delegate.focusNextComponent(aComponent);
061 }
062
063 public void focusPreviousComponent(Component aComponent) {
064 delegate.focusPreviousComponent(aComponent);
065 }
066
067 // Make sure that we delegate all new methods in KeyboardFocusManager
068 // as well as the legacy methods from Swing. It is theoretically possible,
069 // although unlikely, that a client app will treat this instance as a
070 // new-style KeyboardFocusManager. We might as well be safe.
071 //
072 // The JLS won't let us override the protected methods in
073 // KeyboardFocusManager such that they invoke the corresponding methods on
074 // the delegate. However, since client code would never be able to call
075 // those methods anyways, we don't have to worry about that problem.
076
077 public Component getFocusOwner() {
078 return delegate.getFocusOwner();
079 }
080
081 public void clearGlobalFocusOwner() {
082 delegate.clearGlobalFocusOwner();
083 }
084
085 public Component getPermanentFocusOwner() {
086 return delegate.getPermanentFocusOwner();
087 }
088
089 public Window getFocusedWindow() {
090 return delegate.getFocusedWindow();
091 }
092
093 public Window getActiveWindow() {
094 return delegate.getActiveWindow();
095 }
096
097 public FocusTraversalPolicy getDefaultFocusTraversalPolicy() {
098 return delegate.getDefaultFocusTraversalPolicy();
099 }
100
101 public void setDefaultFocusTraversalPolicy(
102 FocusTraversalPolicy defaultPolicy) {
103 if (delegate != null) {
104 // Will be null when invoked from supers constructor.
105 delegate.setDefaultFocusTraversalPolicy(defaultPolicy);
106 }
107 }
108
109 public void setDefaultFocusTraversalKeys(int id,
110 Set<? extends AWTKeyStroke> keystrokes) {
111 delegate.setDefaultFocusTraversalKeys(id, keystrokes);
112 }
113
114 public Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id) {
115 return delegate.getDefaultFocusTraversalKeys(id);
116 }
117
118 public Container getCurrentFocusCycleRoot() {
119 return delegate.getCurrentFocusCycleRoot();
120 }
121
122 public void setGlobalCurrentFocusCycleRoot(
123 Container newFocusCycleRoot) {
124 delegate.setGlobalCurrentFocusCycleRoot(newFocusCycleRoot);
125 }
126
127 public void addPropertyChangeListener(
128 PropertyChangeListener listener) {
129 delegate.addPropertyChangeListener(listener);
130 }
131
132 public void removePropertyChangeListener(
133 PropertyChangeListener listener) {
134 delegate.removePropertyChangeListener(listener);
135 }
136
137 public void addPropertyChangeListener(String propertyName,
138 PropertyChangeListener listener) {
139 delegate.addPropertyChangeListener(propertyName, listener);
140 }
141
142 public void removePropertyChangeListener(String propertyName,
143 PropertyChangeListener listener) {
144 delegate.removePropertyChangeListener(propertyName, listener);
145 }
146
147 public void addVetoableChangeListener(
148 VetoableChangeListener listener) {
149 delegate.addVetoableChangeListener(listener);
150 }
151
152 public void removeVetoableChangeListener(
153 VetoableChangeListener listener) {
154 delegate.removeVetoableChangeListener(listener);
155 }
156
157 public void addVetoableChangeListener(String propertyName,
158 VetoableChangeListener listener) {
159 delegate.addVetoableChangeListener(propertyName, listener);
160 }
161
162 public void removeVetoableChangeListener(String propertyName,
163 VetoableChangeListener listener) {
164 delegate.removeVetoableChangeListener(propertyName, listener);
165 }
166
167 public void addKeyEventDispatcher(KeyEventDispatcher dispatcher) {
168 delegate.addKeyEventDispatcher(dispatcher);
169 }
170
171 public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) {
172 delegate.removeKeyEventDispatcher(dispatcher);
173 }
174
175 public boolean dispatchEvent(AWTEvent e) {
176 return delegate.dispatchEvent(e);
177 }
178
179 public boolean dispatchKeyEvent(KeyEvent e) {
180 return delegate.dispatchKeyEvent(e);
181 }
182
183 public void upFocusCycle(Component aComponent) {
184 delegate.upFocusCycle(aComponent);
185 }
186
187 public void downFocusCycle(Container aContainer) {
188 delegate.downFocusCycle(aContainer);
189 }
190 }
|