1/* 2 * Copyright (c) 2001, 2004, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25package javax.swing; 26 27import java.awt.*; 28import java.awt.event.*; 29import java.beans.*; 30import java.util.Set; 31 32 33/** 34 * Provides a javax.swing.DefaultFocusManager view onto an arbitrary 35 * java.awt.KeyboardFocusManager. We subclass DefaultFocusManager instead of 36 * FocusManager because it seems more backward-compatible. It is likely that 37 * some pre-1.4 code assumes that the object returned by 38 * FocusManager.getCurrentManager is an instance of DefaultFocusManager unless 39 * set explicitly. 40 */ 41final class DelegatingDefaultFocusManager extends DefaultFocusManager { 42 private final KeyboardFocusManager delegate; 43 44 DelegatingDefaultFocusManager(KeyboardFocusManager delegate) { 45 this.delegate = delegate; 46 setDefaultFocusTraversalPolicy(gluePolicy); 47 } 48 49 KeyboardFocusManager getDelegate() { 50 return delegate; 51 } 52 53 // Legacy methods which first appeared in javax.swing.FocusManager. 54 // Client code is most likely to invoke these methods. 55 56 public void processKeyEvent(Component focusedComponent, KeyEvent e) { 57 delegate.processKeyEvent(focusedComponent, e); 58 } 59 public void focusNextComponent(Component aComponent) { 60 delegate.focusNextComponent(aComponent); 61 } 62 public void focusPreviousComponent(Component aComponent) { 63 delegate.focusPreviousComponent(aComponent); 64 } 65 66 // Make sure that we delegate all new methods in KeyboardFocusManager 67 // as well as the legacy methods from Swing. It is theoretically possible, 68 // although unlikely, that a client app will treat this instance as a 69 // new-style KeyboardFocusManager. We might as well be safe. 70 // 71 // The JLS won't let us override the protected methods in 72 // KeyboardFocusManager such that they invoke the corresponding methods on 73 // the delegate. However, since client code would never be able to call 74 // those methods anyways, we don't have to worry about that problem. 75 76 public Component getFocusOwner() { 77 return delegate.getFocusOwner(); 78 } 79 public void clearGlobalFocusOwner() { 80 delegate.clearGlobalFocusOwner(); 81 } 82 public Component getPermanentFocusOwner() { 83 return delegate.getPermanentFocusOwner(); 84 } 85 public Window getFocusedWindow() { 86 return delegate.getFocusedWindow(); 87 } 88 public Window getActiveWindow() { 89 return delegate.getActiveWindow(); 90 } 91 public FocusTraversalPolicy getDefaultFocusTraversalPolicy() { 92 return delegate.getDefaultFocusTraversalPolicy(); 93 } 94 public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy 95 defaultPolicy) { 96 if (delegate != null) { 97 // Will be null when invoked from supers constructor. 98 delegate.setDefaultFocusTraversalPolicy(defaultPolicy); 99 } 100 } 101 public void 102 setDefaultFocusTraversalKeys(int id, 103 Set<? extends AWTKeyStroke> keystrokes) 104 { 105 delegate.setDefaultFocusTraversalKeys(id, keystrokes); 106 } 107 public Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id) { 108 return delegate.getDefaultFocusTraversalKeys(id); 109 } 110 public Container getCurrentFocusCycleRoot() { 111 return delegate.getCurrentFocusCycleRoot(); 112 } 113 public void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot) { 114 delegate.setGlobalCurrentFocusCycleRoot(newFocusCycleRoot); 115 } 116 public void addPropertyChangeListener(PropertyChangeListener listener) { 117 delegate.addPropertyChangeListener(listener); 118 } 119 public void removePropertyChangeListener(PropertyChangeListener listener) { 120 delegate.removePropertyChangeListener(listener); 121 } 122 public void addPropertyChangeListener(String propertyName, 123 PropertyChangeListener listener) { 124 delegate.addPropertyChangeListener(propertyName, listener); 125 } 126 public void removePropertyChangeListener(String propertyName, 127 PropertyChangeListener listener) { 128 delegate.removePropertyChangeListener(propertyName, listener); 129 } 130 public void addVetoableChangeListener(VetoableChangeListener listener) { 131 delegate.addVetoableChangeListener(listener); 132 } 133 public void removeVetoableChangeListener(VetoableChangeListener listener) { 134 delegate.removeVetoableChangeListener(listener); 135 } 136 public void addVetoableChangeListener(String propertyName, 137 VetoableChangeListener listener) { 138 delegate.addVetoableChangeListener(propertyName, listener); 139 } 140 public void removeVetoableChangeListener(String propertyName, 141 VetoableChangeListener listener) { 142 delegate.removeVetoableChangeListener(propertyName, listener); 143 } 144 public void addKeyEventDispatcher(KeyEventDispatcher dispatcher) { 145 delegate.addKeyEventDispatcher(dispatcher); 146 } 147 public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) { 148 delegate.removeKeyEventDispatcher(dispatcher); 149 } 150 public boolean dispatchEvent(AWTEvent e) { 151 return delegate.dispatchEvent(e); 152 } 153 public boolean dispatchKeyEvent(KeyEvent e) { 154 return delegate.dispatchKeyEvent(e); 155 } 156 public void upFocusCycle(Component aComponent) { 157 delegate.upFocusCycle(aComponent); 158 } 159 public void downFocusCycle(Container aContainer) { 160 delegate.downFocusCycle(aContainer); 161 } 162} 163