How can we prevent JTabbedPanes from transferring focus to components outside of the tabs during tab traversal?

Question

Hi,
I noticed a strange focus traversal behavior of JTabbedPane.
During tab traversal (when the user's intention is just to switch between tabs), the focus is transferred to a component outside of the tabs (if there is a component after/below the JTabbedPane component), if using Java 6. For example, if using the SSCCE below...
import java.awt.BorderLayout;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyEvent;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
public class TabbedPaneTest extends JPanel {
    public TabbedPaneTest() {
        super(new BorderLayout());
        JTabbedPane tabbedPane = new JTabbedPane();
        tabbedPane.addTab("Tab 1", buildPanelWithChildComponents());
        tabbedPane.setMnemonicAt(0, KeyEvent.VK_1);
        tabbedPane.addTab("Tab 2", buildPanelWithChildComponents());
        tabbedPane.setMnemonicAt(1, KeyEvent.VK_2);
        tabbedPane.addTab("Tab 3", buildPanelWithChildComponents());
        tabbedPane.setMnemonicAt(2, KeyEvent.VK_3);
        tabbedPane.addTab("Tab 4", buildPanelWithChildComponents());
        tabbedPane.setMnemonicAt(3, KeyEvent.VK_4);
        JPanel panel = new JPanel(new BorderLayout());
        panel.add(tabbedPane);
        JButton button = new JButton("Dummy component that gains focus when switching tabs");
        panel.add(button, BorderLayout.SOUTH);
         * To replicate the focus traversal issue, please follow these steps -
         * 1) Run this program in Java 6; and then
         * 2) Click on a child component inside any tab; and then
         * 3) Click on any other tab (or use the mnemonic keys ALT + 1 to ALT 4).
        button.addFocusListener(new FocusAdapter() {
            @Override
            public void focusGained(FocusEvent e) {
                System.err.println("Gained focus (not supposed to when just switching tabs).");
        add(new JScrollPane(panel));
    private JPanel buildPanelWithChildComponents() {
        JPanel panel = new JPanel();
        BoxLayout boxlayout = new BoxLayout(panel, BoxLayout.PAGE_AXIS);
        panel.setLayout(boxlayout);
        panel.add(Box.createVerticalStrut(3));
        for (int i = 0; i < 4; i++) {
            panel.add(new JTextField(10));
            panel.add(Box.createVerticalStrut(3));
        return panel;
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Test for Java 6");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TabbedPaneTest());
                frame.pack();
                frame.setVisible(true);
... Then we can replicate this behavior by following these steps:
1) Run the program in Java 6; and then
2) Click on a child component in any of the tabs; and then
3) Click on any other tab (or use the mnemonic keys 'ALT + 1' to 'ALT + 4').
At step 3 (upon selecting any other tab), the focus would go to the component below the JTabbedPane first (hence the printed message in the console), before actually going to the selected tab.
This does not occur in Java 7, so I'm assuming it is a bug that is fixed. And I know that Oracle suggests that we should use Java 7 nowadays.
The problem is: We need to stick to Java 6 for a certain application. So I'm looking for a way to fix this issue for all our JTabbedPane components while using Java 6.
So, is there a way to prevent JTabbedPanes from passing the focus to components outside of the tabs during tab traversal (e.g. when users are just switching between tabs), in Java 6?
Note: I've read the release notes between Java 6u45 to Java 7u15, but I was unable to find any changes related to the JTabbedPane component. So any pointers on this would be deeply appreciated.
Regards,
James

Answer 1

Hi Kleopatra,
Thanks for the reply.
Please allow me to clarify first: Actually the problem is not that the child components (inside tabs) get focused before the selected tab. The problem is: the component outside of the tabs gets focused before the selected tab. For example, the JButton in the SSCCE posted above gets focused when users switch between tabs, despite the fact that the JButton is not a child component of the JTabbedPane.
It is important for me to prevent this behavior because it causes a usability issue for forms with 'auto-scrolling' features.
What I mean by 'auto-scrolling' here is: a feature where the form automatically scrolls down to show the current focused component (if the component is not already visible). This is a usability improvement for long forms with scroll bars (which saves the users' effort of manually scrolling down just to see the focused component).
To see this feature in action, please run the SSCCE below, and keep pressing the 'Tab' key (the scroll pane will follow the focused component automatically):
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyEvent;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextField;
import javax.swing.JViewport;
import javax.swing.SwingUtilities;
public class TabbedPaneAutoScrollTest extends JPanel {
    private AutoScrollFocusHandler autoScrollFocusHandler;
    public TabbedPaneAutoScrollTest() {
        super(new BorderLayout());
        autoScrollFocusHandler = new AutoScrollFocusHandler();
        JTabbedPane tabbedPane = new JTabbedPane();
        tabbedPane.addTab("Tab 1", buildPanelWithChildComponents(20));
        tabbedPane.setMnemonicAt(0, KeyEvent.VK_1);
        tabbedPane.addTab("Tab 2", buildPanelWithChildComponents(20));
        tabbedPane.setMnemonicAt(1, KeyEvent.VK_2);
        tabbedPane.addTab("Tab 3", buildPanelWithChildComponents(20));
        tabbedPane.setMnemonicAt(2, KeyEvent.VK_3);
        tabbedPane.addTab("Tab 4", buildPanelWithChildComponents(20));
        tabbedPane.setMnemonicAt(3, KeyEvent.VK_4);
        JPanel panel = new JPanel(new BorderLayout());
        panel.add(tabbedPane);
        JButton button = new JButton("Dummy component that gains focus when switching tabs");
        panel.add(button, BorderLayout.SOUTH);
         * To replicate the focus traversal issue, please follow these steps -
         * 1) Run this program in Java 6; and then
         * 2) Click on a child component inside any tab; and then
         * 3) Click on any other tab (or use the mnemonic keys ALT + 1 to ALT 4).
        button.addFocusListener(new FocusAdapter() {
            @Override
            public void focusGained(FocusEvent e) {
                System.err.println("Gained focus (not supposed to when just switching tabs).");
        button.addFocusListener(autoScrollFocusHandler);
        JScrollPane scrollPane = new JScrollPane(panel);
        add(scrollPane);
        autoScrollFocusHandler.setScrollPane(scrollPane);
    private JPanel buildPanelWithChildComponents(int numberOfChildComponents) {
        final JPanel panel = new JPanel(new GridBagLayout());
        final String labelPrefix = "Dummy Field ";
        final Insets labelInsets = new Insets(5, 5, 5, 5);
        final Insets textFieldInsets = new Insets(5, 0, 5, 0);
        final GridBagConstraints gridBagConstraints = new GridBagConstraints();
        JTextField textField;
        for (int i = 0; i < numberOfChildComponents; i++) {
            gridBagConstraints.insets = labelInsets;
            gridBagConstraints.gridx = 1;
            gridBagConstraints.gridy = i;
            panel.add(new JLabel(labelPrefix + (i + 1)), gridBagConstraints);
            gridBagConstraints.insets = textFieldInsets;
            gridBagConstraints.gridx = 2;
            textField = new JTextField(22);
            panel.add(textField, gridBagConstraints);
            textField.addFocusListener(autoScrollFocusHandler);
        return panel;
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                JFrame frame = new JFrame("Test for Java 6 with auto-scrolling");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TabbedPaneAutoScrollTest());
                frame.setSize(400, 300);
                frame.setVisible(true);
* Crude but simple example for auto-scrolling to focused components.
* Note: We don't actually use FocusListeners for this feature,
*       but this is short enough to demonstrate how it behaves.
class AutoScrollFocusHandler extends FocusAdapter {
    private JViewport viewport;
    private JComponent view;
    public void setScrollPane(JScrollPane scrollPane) {
        viewport = scrollPane.getViewport();
        view = (JComponent) viewport.getView();
    @Override
    public void focusGained(FocusEvent event) {
        Component component = (Component) event.getSource();
        view.scrollRectToVisible(SwingUtilities.convertRectangle(component.getParent(),
                component.getBounds(), view));
Now, while the focus is still within the tab contents, try to switch to any other tab (e.g. by clicking on the tab headers, or by using the mnemonic keys 'ALT + 1' to 'ALT + 4')...
... then you'll notice the following usability issue:
1) JRE 1.6 causes the focus to transfer to the JButton (which is outside of the tabs entirely) first; then
2) In response to the JButton gaining focus, the 'auto-scrolling' feature scrolls down to the bottom of the form, to show the JButton. At this point, the tab headers are hidden from view since there are many child components; then
3) JRE 1.6 transfers the focus to the tab contents; then
4) The 'auto-scrolling' feature scrolls up to the selected tab's contents, but the tab header itself is still hidden from view (as a side effect of the behavior above); then
5) Users are forced to manually scroll up to see the tab headers whenever they are just switching between tabs.
In short, the tab headers will be hidden when users switch tabs, due to the Java 6 behavior posted above.
That is why it is important for me to prevent the behavior in my first post above (so that it won't cause usability issues when we apply the 'auto-scrolling' feature to our forms).
Best Regards,
James