1. /*
  2. * @(#)DelegatingDefaultFocusManager.java 1.5 04/05/05
  3. *
  4. * Copyright 2004 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
  75. setDefaultFocusTraversalKeys(int id,
  76. Set<? extends AWTKeyStroke> keystrokes)
  77. {
  78. delegate.setDefaultFocusTraversalKeys(id, keystrokes);
  79. }
  80. public Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id) {
  81. return delegate.getDefaultFocusTraversalKeys(id);
  82. }
  83. public Container getCurrentFocusCycleRoot() {
  84. return delegate.getCurrentFocusCycleRoot();
  85. }
  86. public void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot) {
  87. delegate.setGlobalCurrentFocusCycleRoot(newFocusCycleRoot);
  88. }
  89. public void addPropertyChangeListener(PropertyChangeListener listener) {
  90. delegate.addPropertyChangeListener(listener);
  91. }
  92. public void removePropertyChangeListener(PropertyChangeListener listener) {
  93. delegate.removePropertyChangeListener(listener);
  94. }
  95. public void addPropertyChangeListener(String propertyName,
  96. PropertyChangeListener listener) {
  97. delegate.addPropertyChangeListener(propertyName, listener);
  98. }
  99. public void removePropertyChangeListener(String propertyName,
  100. PropertyChangeListener listener) {
  101. delegate.removePropertyChangeListener(propertyName, listener);
  102. }
  103. public void addVetoableChangeListener(VetoableChangeListener listener) {
  104. delegate.addVetoableChangeListener(listener);
  105. }
  106. public void removeVetoableChangeListener(VetoableChangeListener listener) {
  107. delegate.removeVetoableChangeListener(listener);
  108. }
  109. public void addVetoableChangeListener(String propertyName,
  110. VetoableChangeListener listener) {
  111. delegate.addVetoableChangeListener(propertyName, listener);
  112. }
  113. public void removeVetoableChangeListener(String propertyName,
  114. VetoableChangeListener listener) {
  115. delegate.removeVetoableChangeListener(propertyName, listener);
  116. }
  117. public void addKeyEventDispatcher(KeyEventDispatcher dispatcher) {
  118. delegate.addKeyEventDispatcher(dispatcher);
  119. }
  120. public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) {
  121. delegate.removeKeyEventDispatcher(dispatcher);
  122. }
  123. public boolean dispatchEvent(AWTEvent e) {
  124. return delegate.dispatchEvent(e);
  125. }
  126. public boolean dispatchKeyEvent(KeyEvent e) {
  127. return delegate.dispatchKeyEvent(e);
  128. }
  129. public void upFocusCycle(Component aComponent) {
  130. delegate.upFocusCycle(aComponent);
  131. }
  132. public void downFocusCycle(Container aContainer) {
  133. delegate.downFocusCycle(aContainer);
  134. }
  135. }