| Frames | No Frames |
1: /* FocusManager.java -- 2: Copyright (C) 2002, 2004 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.swing; 40: 41: import java.awt.AWTEvent; 42: import java.awt.Component; 43: import java.awt.Container; 44: import java.awt.DefaultKeyboardFocusManager; 45: import java.awt.FocusTraversalPolicy; 46: import java.awt.KeyEventDispatcher; 47: import java.awt.KeyEventPostProcessor; 48: import java.awt.KeyboardFocusManager; 49: import java.awt.Window; 50: import java.awt.event.KeyEvent; 51: import java.beans.PropertyChangeListener; 52: import java.beans.VetoableChangeListener; 53: import java.util.Set; 54: 55: /** 56: * This class has been obsoleted by the new 57: * {@link java.awt.KeyboardFocusManager} and 58: * {@link java.awt.DefaultKeyboardFocusManager} API. 59: * 60: * @author Andrew Selkirk 61: */ 62: public abstract class FocusManager 63: extends DefaultKeyboardFocusManager 64: { 65: /** 66: * A FocusManager that wraps an AWT KeyboardFocusManager and forwards all 67: * method calls to it. This is used for compatibility with the new focus 68: * system. 69: * 70: * @author Roman Kennke (kennke@aicas.com) 71: */ 72: private static class WrappingFocusManager 73: extends FocusManager 74: { 75: /** 76: * The wrapped KeyboardFocusManager. 77: */ 78: private KeyboardFocusManager wrapped; 79: 80: /** 81: * Creates a new instance of WrappedFocusManager. 82: * 83: * @param fm the focus manager to wrap 84: */ 85: WrappingFocusManager(KeyboardFocusManager fm) 86: { 87: wrapped = fm; 88: } 89: 90: /** 91: * Wraps {@link DefaultKeyboardFocusManager#dispatchEvent(AWTEvent)}. 92: * 93: * @param ev the event to dispatch 94: * 95: * @return <code>true</code> if the event has been dispatched, 96: * <code>false</code> otherwise 97: */ 98: public boolean dispatchEvent(AWTEvent ev) 99: { 100: return wrapped.dispatchEvent(ev); 101: } 102: 103: /** 104: * Wraps {@link DefaultKeyboardFocusManager#dispatchKeyEvent(KeyEvent)}. 105: * 106: * @param ev the event to dispatch 107: * 108: * @return <code>true</code> if the event has been dispatched, 109: * <code>false</code> otherwise 110: */ 111: public boolean dispatchKeyEvent(KeyEvent ev) 112: { 113: return wrapped.dispatchKeyEvent(ev); 114: } 115: 116: /** 117: * Wraps {@link DefaultKeyboardFocusManager#downFocusCycle(Container)}. 118: * 119: * @param c the container 120: */ 121: public void downFocusCycle(Container c) 122: { 123: wrapped.downFocusCycle(c); 124: } 125: 126: /** 127: * Wraps {@link DefaultKeyboardFocusManager#upFocusCycle(Container)}. 128: * 129: * @param c the container 130: */ 131: public void upFocusCycle(Container c) 132: { 133: wrapped.upFocusCycle(c); 134: } 135: 136: /** 137: * Wraps {@link DefaultKeyboardFocusManager#focusNextComponent(Component)}. 138: * 139: * @param c the component 140: */ 141: public void focusNextComponent(Component c) 142: { 143: wrapped.focusNextComponent(c); 144: } 145: 146: /** 147: * Wraps 148: * {@link DefaultKeyboardFocusManager#focusPreviousComponent(Component)}. 149: * 150: * @param c the component 151: */ 152: public void focusPreviousComponent(Component c) 153: { 154: wrapped.focusPreviousComponent(c); 155: } 156: 157: /** 158: * Wraps {@link DefaultKeyboardFocusManager#postProcessKeyEvent(KeyEvent)}. 159: * 160: * @param e the key event 161: * 162: * @return a boolead 163: */ 164: public boolean postProcessKeyEvent(KeyEvent e) 165: { 166: return wrapped.postProcessKeyEvent(e); 167: } 168: 169: /** 170: * Wraps 171: * {@link DefaultKeyboardFocusManager#processKeyEvent(Component, KeyEvent)}. 172: * 173: * @param c the component 174: * @param e the key event 175: */ 176: public void processKeyEvent(Component c, KeyEvent e) 177: { 178: wrapped.processKeyEvent(c, e); 179: } 180: 181: /** 182: * Wraps 183: * {@link KeyboardFocusManager#addKeyEventDispatcher(KeyEventDispatcher)}. 184: * 185: * @param d the dispatcher 186: */ 187: public void addKeyEventDispatcher(KeyEventDispatcher d) 188: { 189: wrapped.addKeyEventDispatcher(d); 190: } 191: 192: /** 193: * Wraps 194: * {@link KeyboardFocusManager#addKeyEventPostProcessor(KeyEventPostProcessor)}. 195: * 196: * @param p the post processor 197: */ 198: public void addKeyEventPostProcessor(KeyEventPostProcessor p) 199: { 200: wrapped.addKeyEventPostProcessor(p); 201: } 202: 203: /** 204: * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(PropertyChangeListener)}. 205: * 206: * @param l the property change listener 207: */ 208: public void addPropertyChangeListener(PropertyChangeListener l) 209: { 210: wrapped.addPropertyChangeListener(l); 211: } 212: 213: /** 214: * Wraps {@link KeyboardFocusManager#addPropertyChangeListener(String, PropertyChangeListener)}. 215: * 216: * @param p the property name 217: * @param l the property change listener 218: */ 219: public void addPropertyChangeListener(String p, PropertyChangeListener l) 220: { 221: wrapped.addPropertyChangeListener(p, l); 222: } 223: 224: /** 225: * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(String, VetoableChangeListener)}. 226: * 227: * @param p the property name 228: * @param l the vetoable change listener 229: */ 230: public void addVetoableChangeListener(String p, VetoableChangeListener l) 231: { 232: wrapped.addVetoableChangeListener(p, l); 233: } 234: 235: /** 236: * Wraps {@link KeyboardFocusManager#addVetoableChangeListener(VetoableChangeListener)}. 237: * 238: * @param l the vetoable change listener 239: */ 240: public void addVetoableChangeListener(VetoableChangeListener l) 241: { 242: wrapped.addVetoableChangeListener(l); 243: } 244: 245: /** 246: * Wraps {@link KeyboardFocusManager#clearGlobalFocusOwner()}. 247: */ 248: public void clearGlobalFocusOwner() 249: { 250: wrapped.clearGlobalFocusOwner(); 251: } 252: 253: /** 254: * Wraps {@link KeyboardFocusManager#getActiveWindow()}. 255: * 256: * @return the active window 257: */ 258: public Window getActiveWindow() 259: { 260: return wrapped.getActiveWindow(); 261: } 262: 263: /** 264: * Wraps {@link KeyboardFocusManager#getCurrentFocusCycleRoot()}. 265: * 266: * @return the focus cycle root 267: */ 268: public Container getCurrentFocusCycleRoot() 269: { 270: return wrapped.getCurrentFocusCycleRoot(); 271: } 272: 273: /** 274: * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalKeys(int)}. 275: * 276: * @param i the ID 277: * 278: * @return the focus traversal keys 279: */ 280: public Set getDefaultFocusTraversalKeys(int i) 281: { 282: return wrapped.getDefaultFocusTraversalKeys(i); 283: } 284: 285: /** 286: * Wraps {@link KeyboardFocusManager#getDefaultFocusTraversalPolicy()}. 287: * 288: * @return the focus traversal policy 289: */ 290: public FocusTraversalPolicy getDefaultFocusTraversalPolicy() 291: { 292: return wrapped.getDefaultFocusTraversalPolicy(); 293: } 294: 295: /** 296: * Wraps {@link KeyboardFocusManager#getFocusedWindow()}. 297: * 298: * @return the focused window 299: */ 300: public Window getFocusedWindow() 301: { 302: return wrapped.getFocusedWindow(); 303: } 304: 305: /** 306: * Wraps {@link KeyboardFocusManager#getFocusOwner()}. 307: * 308: * @return the focus owner 309: */ 310: public Component getFocusOwner() 311: { 312: return wrapped.getFocusOwner(); 313: } 314: 315: /** 316: * Wraps {@link KeyboardFocusManager#getPermanentFocusOwner()}. 317: * 318: * @return the focus owner 319: */ 320: public Component getPermanentFocusOwner() 321: { 322: return wrapped.getPermanentFocusOwner(); 323: } 324: 325: /** 326: * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners()}. 327: * 328: * @return the property change listeners 329: */ 330: public PropertyChangeListener[] getPropertyChangeListeners() 331: { 332: return wrapped.getPropertyChangeListeners(); 333: } 334: 335: /** 336: * Wraps {@link KeyboardFocusManager#getPropertyChangeListeners(String)}. 337: * 338: * @param n the property name 339: * 340: * @return the property change listeners 341: */ 342: public PropertyChangeListener[] getPropertyChangeListeners(String n) 343: { 344: return wrapped.getPropertyChangeListeners(n); 345: } 346: 347: /** 348: * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners()}. 349: * 350: * @return the vetoable change listeners 351: */ 352: public VetoableChangeListener[] getVetoableChangeListeners() 353: { 354: return wrapped.getVetoableChangeListeners(); 355: } 356: 357: /** 358: * Wraps {@link KeyboardFocusManager#getVetoableChangeListeners(String)}. 359: * 360: * @param n the property name 361: * 362: * @return the vetoable change listeners 363: */ 364: public VetoableChangeListener[] getVetoableChangeListeners(String n) 365: { 366: return wrapped.getVetoableChangeListeners(n); 367: } 368: 369: 370: /** 371: * Wraps 372: * {@link KeyboardFocusManager#removeKeyEventDispatcher(KeyEventDispatcher)}. 373: * 374: * @param d the key event dispatcher to remove 375: */ 376: public void removeKeyEventDispatcher(KeyEventDispatcher d) 377: { 378: wrapped.removeKeyEventDispatcher(d); 379: } 380: 381: /** 382: * Wraps 383: * {@link KeyboardFocusManager#removeKeyEventPostProcessor(KeyEventPostProcessor)}. 384: * 385: * @param p the post processor 386: */ 387: public void removeKeyEventPostProcessor(KeyEventPostProcessor p) 388: { 389: wrapped.removeKeyEventPostProcessor(p); 390: } 391: 392: /** 393: * Wraps 394: * {@link KeyboardFocusManager#removePropertyChangeListener(PropertyChangeListener)}. 395: * 396: * @param l the listener 397: */ 398: public void removePropertyChangeListener(PropertyChangeListener l) 399: { 400: wrapped.removePropertyChangeListener(l); 401: } 402: 403: /** 404: * Wraps 405: * {@link KeyboardFocusManager#removePropertyChangeListener(String, PropertyChangeListener)}. 406: * 407: * @param n the property name 408: * @param l the listener 409: */ 410: public void removePropertyChangeListener(String n, PropertyChangeListener l) 411: { 412: wrapped.removePropertyChangeListener(n, l); 413: } 414: 415: /** 416: * Wraps 417: * {@link KeyboardFocusManager#removeVetoableChangeListener(VetoableChangeListener)}. 418: * 419: * @param l the listener 420: */ 421: public void removeVetoableChangeListener(VetoableChangeListener l) 422: { 423: wrapped.removeVetoableChangeListener(l); 424: } 425: 426: /** 427: * Wraps 428: * {@link KeyboardFocusManager#removeVetoableChangeListener(String, VetoableChangeListener)}. 429: * 430: * @param n the property name 431: * @param l the listener 432: */ 433: public void removeVetoableChangeListener(String n, VetoableChangeListener l) 434: { 435: wrapped.removeVetoableChangeListener(n, l); 436: } 437: 438: /** 439: * Wraps 440: * {@link KeyboardFocusManager#setDefaultFocusTraversalKeys(int, Set)}. 441: * 442: * @param id the ID 443: * @param k the keystrokes 444: */ 445: public void setDefaultFocusTraversalKeys(int id, Set k) 446: { 447: wrapped.setDefaultFocusTraversalKeys(id, k); 448: } 449: 450: /** 451: * Wraps {@link KeyboardFocusManager#setDefaultFocusTraversalPolicy(FocusTraversalPolicy)}. 452: * 453: * @param p the focus traversal policy 454: */ 455: public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy p) 456: { 457: wrapped.setDefaultFocusTraversalPolicy(p); 458: } 459: 460: /** 461: * Wraps 462: * {@link KeyboardFocusManager#setGlobalCurrentFocusCycleRoot(Container)}. 463: * 464: * @param r the focus cycle root 465: */ 466: public void setGlobalCurrentFocusCycleRoot(Container r) 467: { 468: wrapped.setGlobalCurrentFocusCycleRoot(r); 469: } 470: } 471: 472: /** 473: * FOCUS_MANAGER_CLASS_PROPERTY 474: */ 475: public static final String FOCUS_MANAGER_CLASS_PROPERTY = 476: "FocusManagerClassName"; 477: 478: /** 479: * Constructor FocusManager 480: */ 481: public FocusManager() 482: { 483: super(); 484: } 485: 486: /** 487: * getCurrentManager 488: * @return FocusManager 489: */ 490: public static FocusManager getCurrentManager() 491: { 492: KeyboardFocusManager m = 493: KeyboardFocusManager.getCurrentKeyboardFocusManager(); 494: return new WrappingFocusManager(m); 495: } 496: 497: /** 498: * setCurrentManager 499: * @param manager TODO 500: */ 501: public static void setCurrentManager(FocusManager manager) 502: { 503: KeyboardFocusManager.setCurrentKeyboardFocusManager(manager); 504: } 505: 506: /** 507: * disableSwingFocusManager 508: * @deprecated 1.4 509: */ 510: public static void disableSwingFocusManager() 511: { 512: // TODO 513: } 514: 515: /** 516: * isFocusManagerEnabled 517: * @return boolean 518: * @deprecated 1.4 519: */ 520: public static boolean isFocusManagerEnabled() 521: { 522: return false; // TODO 523: } 524: }