DelegatingDefaultFocusManager(KeyboardFocusManager delegate) 
{
        this.delegate = delegate;
        setDefaultFocusTraversalPolicy(gluePolicy);
}

 public  void addKeyEventDispatcher(KeyEventDispatcher dispatcher) 
{
        delegate.addKeyEventDispatcher(dispatcher);
}

 public  void addPropertyChangeListener(PropertyChangeListener listener) 
{
        delegate.addPropertyChangeListener(listener);
}

 public  void addPropertyChangeListener(String propertyName,
    PropertyChangeListener listener) 
{
        delegate.addPropertyChangeListener(propertyName, listener);
}

 public  void addVetoableChangeListener(VetoableChangeListener listener) 
{
        delegate.addVetoableChangeListener(listener);
}

 public  void addVetoableChangeListener(String propertyName,
    VetoableChangeListener listener) 
{
        delegate.addVetoableChangeListener(propertyName, listener);
}

 public  void clearGlobalFocusOwner() 
{
        delegate.clearGlobalFocusOwner();
}

 public boolean dispatchEvent(AWTEvent e) 
{
        return delegate.dispatchEvent(e);
}

 public boolean dispatchKeyEvent(KeyEvent e) 
{
        return delegate.dispatchKeyEvent(e);
}

 public  void downFocusCycle(Container aContainer) 
{
        delegate.downFocusCycle(aContainer);
}

 public  void focusNextComponent(Component aComponent) 
{
        delegate.focusNextComponent(aComponent);
}

 public  void focusPreviousComponent(Component aComponent) 
{
        delegate.focusPreviousComponent(aComponent);
}

 public Window getActiveWindow() 
{
        return delegate.getActiveWindow();
}

 public Container getCurrentFocusCycleRoot() 
{
        return delegate.getCurrentFocusCycleRoot();
}

 public Set getDefaultFocusTraversalKeys(int id) 
{
        return delegate.getDefaultFocusTraversalKeys(id);
}

 public FocusTraversalPolicy getDefaultFocusTraversalPolicy() 
{
        return delegate.getDefaultFocusTraversalPolicy();
}

 KeyboardFocusManager getDelegate() 
{
        return delegate;
}

 public Component getFocusOwner() 
{
        return delegate.getFocusOwner();
}

 public Window getFocusedWindow() 
{
        return delegate.getFocusedWindow();
}

 public Component getPermanentFocusOwner() 
{
        return delegate.getPermanentFocusOwner();
}

 public  void processKeyEvent(Component focusedComponent,
    KeyEvent e) 
{
        delegate.processKeyEvent(focusedComponent, e);
}

 public  void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) 
{
        delegate.removeKeyEventDispatcher(dispatcher);
}

 public  void removePropertyChangeListener(PropertyChangeListener listener) 
{
        delegate.removePropertyChangeListener(listener);
}

 public  void removePropertyChangeListener(String propertyName,
    PropertyChangeListener listener) 
{
        delegate.removePropertyChangeListener(propertyName, listener);
}

 public  void removeVetoableChangeListener(VetoableChangeListener listener) 
{
        delegate.removeVetoableChangeListener(listener);
}

 public  void removeVetoableChangeListener(String propertyName,
    VetoableChangeListener listener) 
{
        delegate.removeVetoableChangeListener(propertyName, listener);
}

 public  void setDefaultFocusTraversalKeys(int id,
    Set keystrokes) 
{
        delegate.setDefaultFocusTraversalKeys(id, keystrokes);
}

 public  void setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy) 
{
        if (delegate != null) {
            // Will be null when invoked from supers constructor.
            delegate.setDefaultFocusTraversalPolicy(defaultPolicy);
        }
}

 public  void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot) 
{
        delegate.setGlobalCurrentFocusCycleRoot(newFocusCycleRoot);
}

 public  void upFocusCycle(Component aComponent) 
{
        delegate.upFocusCycle(aComponent);
}