Detect Focus transfer between JPanels

Question

I have an app that has a scrollpane containing a JPanel (A), that contains a bunch of JPanels (B) - each of which contains multiple controls, panels, etc....
I want to make sure that whichever JPanel (B) has the focus in it, and use the viewPort.scrollToVisible() to make sure that panel is fully displayed.
So far, the only way I've seen to do that is to add a FocusListener to each and every control and check to see which panel it's in.
BLECH!
Is there an easier way?
I'd really like some kind of listener that is just notified whenever focus transfers between the upper level Panels.

Answer 1

Thanks to all. Re-read those sections, and came up with this little utility class to do what I needed.
It listens for focus changes between panels, and notifies a listener of these changes.
import java.awt.Component;
import java.awt.KeyboardFocusManager;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import javax.swing.JPanel;
* Tracks the focus for Panels.  If the focus enters or leaves the panel (i.e. focus goes
* to/from any component in the panel, and from/to anything outside the panel)
* It notifies any listeners of the event.
* @author jlussmyer
public class PanelFocusTracker {
    /** Array of panels we are tracking focus changes for. */
    private JPanel[] panels = new JPanel[0];
    /** Which of our tracked panels currently has the focus */
    private JPanel curFocus = null;
     * Constructor.  Ties into focus handling system.
    public PanelFocusTracker() {
        KeyboardFocusManager focusManager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
        focusManager.addPropertyChangeListener(
                new PropertyChangeListener() {
                    @Override
                    public void propertyChange(PropertyChangeEvent e) {
                        String prop = e.getPropertyName();
                        if (("focusOwner".equals(prop)) && ((e.getNewValue()) instanceof Component)) {
                            Component comp = (Component) e.getNewValue();
                            checkForPanelChange(comp);
        return;
     * Check to see if focus going to his component changes which containing
     * panel has the focus.
     * @param comp Component that is gaining focus.
    private void checkForPanelChange(Component comp) {
        JPanel gainPanel = getPanelForComponent(comp);
        if (gainPanel == curFocus) {
            return; // no change, nothing to do.
        if (curFocus != null) {
            notifyListeners(curFocus, false); // This panel lost focus
        if (gainPanel != null) {
            notifyListeners(gainPanel, true); // This panel gained focus
        curFocus = gainPanel;
        return;
     * Finds which of the panels we are tracking contains the given component.
     * @param comp Component to find containing panel for
     * @return Containing Panel, null if it isn't in one of the panels being tracked.
    private JPanel getPanelForComponent(Component comp) {
        JPanel result = null;
        while ((comp != null) && (result == null)) {
            if (isBeingTracked(comp)) {
                result = (JPanel) comp;
            } else {
                comp = comp.getParent();
        return result;
     * Checks to see if this is one of the JPanels we are tracking.
     * @param comp Component to check
     * @return true if it's a JPanel that we are tracking.
    private boolean isBeingTracked(Component comp) {
        boolean result = false;
        for (int idx = 0; (idx < panels.length); idx++) {
            if (comp == panels[idx]) {
                result = true;
                break;
        return result;
     * Add a panel to the list of panels being tracked for Panel Focus
     * changes.
     * @param panel Panel to track focus for.
    public void addPanel(JPanel panel) {
        // Don't allow the same panel to be added multiple times.
        for (int idx = 0; (idx < panels.length); idx++) {
            if (panel == panels[idx]) {
                panel = null;
                break;
        if (panel != null) {
            JPanel[] temp = new JPanel[panels.length + 1];
            System.arraycopy(panels, 0, temp, 0, panels.length);
            temp[panels.length] = panel;
            panels = temp;
        return;
     * Remove a panel from the list of panels being tracked for Panel Focus
     * changes.
     * @param panel Panel to stop tracking focus for.
     * @return true if panel was being tracked, false otherwise.
    public boolean removePanel(JPanel panel) {
        boolean found = false;
        for (int idx = 0; (idx < panels.length); idx++) {
            if (panel == panels[idx]) {
                found = true;
                JPanel[] temp = new JPanel[panels.length - 1];
                if (idx == 0) { // removing first entry
                    if (temp.length > 0) {
                        System.arraycopy(panels, 1, temp, 0, temp.length);
                } else if (idx == (panels.length - 1)) { // remove last entry
                    System.arraycopy(panels, 0, temp, 0, temp.length);
                } else { // Remove something in the middle
                    System.arraycopy(panels, 0, temp, 0, idx);
                    System.arraycopy(panels, idx + 1, temp, idx + 1, temp.length - idx);
                break;
        return found;
     * Remove all JPanels from focus tracking.
    public void removeAllPanels() {
        panels = new JPanel[0];
        curFocus = null;
        return;
     * Interface for listeners to be notified of focus being gained/lost by
     * any of the panels being tracked.
    public interface Listener {
        /** Focus Lost by given panel */
        void panelFocusLost(JPanel panel);
        /** Focus gained by given panel */
        void panelFocusGained(JPanel panel);
    /** Listeners to be notified of Panel Focus changes */
    private ArrayList<Listener> focusListeners = new ArrayList<Listener>();
     * Add a listener to be notified of changes to the Focus for any Panel
     * being tracked.
     * @param listener Listener to be notified for Panel Focus changes.
    public void addListener(Listener listener) {
        focusListeners.add(listener);
        return;
     * Remove a Panel Focus listener.
     * @param listener listener to no longer be notified of Focus changes.
     * @return true if listener found, false otherwise.
    public boolean removeListener(Listener listener) {
        return focusListeners.remove(listener);
     * Notify all registered listeners of a Panel Focus change.
     * @param panel panel that gained/lost focus.
     * @param gained true if focus gained, false if focus lost.
    private void notifyListeners(JPanel panel, boolean gained) {
        Listener[] list = focusListeners.toArray(new Listener[focusListeners.size()]);
        for (int idx = 0; (idx < list.length); idx++) {
            if (gained) {
                list[idx].panelFocusGained(panel);
            } else {
                list[idx].panelFocusLost(panel);
        return;
}