1. /*
  2. * @(#)DelegatingDefaultFocusManager.java 1.3 03/01/23
  3. *
  4. * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
  5. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  6. */
  7. package javax.swing;
  8. import java.awt.*;
  9. import java.awt.event.*;
  10. import java.beans.*;
  11. import java.util.Set;
  12. /**
  13. * Provides a javax.swing.DefaultFocusManager view onto an arbitrary
  14. * java.awt.KeyboardFocusManager. We subclass DefaultFocusManager instead of
  15. * FocusManager because it seems more backward-compatible. It is likely that
  16. * some pre-1.4 code assumes that the object returned by
  17. * FocusManager.getCurrentManager is an instance of DefaultFocusManager unless
  18. * set explicitly.
  19. */
  20. final class DelegatingDefaultFocusManager extends DefaultFocusManager {
  21. private final KeyboardFocusManager delegate;
  22. DelegatingDefaultFocusManager(KeyboardFocusManager delegate) {
  23. this.delegate = delegate;
  24. setDefaultFocusTraversalPolicy(gluePolicy);
  25. }
  26. KeyboardFocusManager getDelegate() {
  27. return delegate;
  28. }
  29. // Legacy methods which first appeared in javax.swing.FocusManager.
  30. // Client code is most likely to invoke these methods.
  31. public void processKeyEvent(Component focusedComponent, KeyEvent e) {
  32. delegate.processKeyEvent(focusedComponent, e);
  33. }
  34. public void focusNextComponent(Component aComponent) {
  35. delegate.focusNextComponent(aComponent);
  36. }
  37. public void focusPreviousComponent(Component aComponent) {
  38. delegate.focusPreviousComponent(aComponent);
  39. }
  40. // Make sure that we delegate all new methods in KeyboardFocusManager
  41. // as well as the legacy methods from Swing. It is theoretically possible,
  42. // although unlikely, that a client app will treat this instance as a
  43. // new-style KeyboardFocusManager. We might as well be safe.
  44. //
  45. // The JLS won't let us override the protected methods in
  46. // KeyboardFocusManager such that they invoke the corresponding methods on
  47. // the delegate. However, since client code would never be able to call
  48. // those methods anyways, we don't have to worry about that problem.
  49. public Component getFocusOwner() {
  50. return delegate.getFocusOwner();
  51. }
  52. public void clearGlobalFocusOwner() {
  53. delegate.clearGlobalFocusOwner();
  54. }
  55. public Component getPermanentFocusOwner() {
  56. return delegate.getPermanentFocusOwner();
  57. }
  58. public Window getFocusedWindow() {
  59. return delegate.getFocusedWindow();
  60. }
  61. public Window getActiveWindow() {
  62. return delegate.getActiveWindow();
  63. }
  64. public FocusTraversalPolicy getDefaultFocusTraversalPolicy() {
  65. return delegate.getDefaultFocusTraversalPolicy();
  66. }
  67. public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy
  68. defaultPolicy) {
  69. if (delegate != null) {
  70. // Will be null when invoked from supers constructor.
  71. delegate.setDefaultFocusTraversalPolicy(defaultPolicy);
  72. }
  73. }
  74. public void setDefaultFocusTraversalKeys(int id, Set keystrokes) {
  75. delegate.setDefaultFocusTraversalKeys(id, keystrokes);
  76. }
  77. public Set getDefaultFocusTraversalKeys(int id) {
  78. return delegate.getDefaultFocusTraversalKeys(id);
  79. }
  80. public Container getCurrentFocusCycleRoot() {
  81. return delegate.getCurrentFocusCycleRoot();
  82. }
  83. public void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot) {
  84. delegate.setGlobalCurrentFocusCycleRoot(newFocusCycleRoot);
  85. }
  86. public void addPropertyChangeListener(PropertyChangeListener listener) {
  87. delegate.addPropertyChangeListener(listener);
  88. }
  89. public void removePropertyChangeListener(PropertyChangeListener listener) {
  90. delegate.removePropertyChangeListener(listener);
  91. }
  92. public void addPropertyChangeListener(String propertyName,
  93. PropertyChangeListener listener) {
  94. delegate.addPropertyChangeListener(propertyName, listener);
  95. }
  96. public void removePropertyChangeListener(String propertyName,
  97. PropertyChangeListener listener) {
  98. delegate.removePropertyChangeListener(propertyName, listener);
  99. }
  100. public void addVetoableChangeListener(VetoableChangeListener listener) {
  101. delegate.addVetoableChangeListener(listener);
  102. }
  103. public void removeVetoableChangeListener(VetoableChangeListener listener) {
  104. delegate.removeVetoableChangeListener(listener);
  105. }
  106. public void addVetoableChangeListener(String propertyName,
  107. VetoableChangeListener listener) {
  108. delegate.addVetoableChangeListener(propertyName, listener);
  109. }
  110. public void removeVetoableChangeListener(String propertyName,
  111. VetoableChangeListener listener) {
  112. delegate.removeVetoableChangeListener(propertyName, listener);
  113. }
  114. public void addKeyEventDispatcher(KeyEventDispatcher dispatcher) {
  115. delegate.addKeyEventDispatcher(dispatcher);
  116. }
  117. public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) {
  118. delegate.removeKeyEventDispatcher(dispatcher);
  119. }
  120. public boolean dispatchEvent(AWTEvent e) {
  121. return delegate.dispatchEvent(e);
  122. }
  123. public boolean dispatchKeyEvent(KeyEvent e) {
  124. return delegate.dispatchKeyEvent(e);
  125. }
  126. public void upFocusCycle(Component aComponent) {
  127. delegate.upFocusCycle(aComponent);
  128. }
  129. public void downFocusCycle(Container aContainer) {
  130. delegate.downFocusCycle(aContainer);
  131. }
  132. }