Why isn't the JDialog triggering the key listener's keyPressed method?

Question

This is my code

 JToolBar customizeKeys = new JToolBar();
 customizeKeys.add(new ChangeKeyListen("left"));
 private class ChangeKeyListen extends AbstractAction{
    private JDialog myDialog;
    class KeyGetter extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            super.keyPressed(e);
            OtherPanel.this.map(
                        KeyEvent.getKeyText(e.getKeyCode()),
                                            keyAction);
            myDialog.setVisible(false);
            myDialog.removeKeyListener(getKeyListeners()[0]);
        }
    };
    public ChangeKeyListen(String name) {
        super(name);
    }
    @Override
    public void actionPerformed(ActionEvent e) {
       myDialog = new JOptionPane().createDialog("Press a key");
       myDialog.setVisible(true);
       myDialog.requestFocusInWindow();
       System.out.println(myDialog.getFocusableWindowState());
       myDialog.addKeyListener(new KeyGetter());
       System.out.println( myDialog.getKeyListeners());
     }
}

What I am trying to do here is when the user clicks the JButton that was added to the JToolBar with the attributes of its action, the user will be prompted with my own customized dialog box. The user can then press any key to close the dialog box.(it actually just be invisible). When I run the application, everything looks fine. The JToolBar looks right and the button looks right. When I click the button, the correct controller behavior occurs as the dialog box is popped up.(just visible) However the key adapter's keyPressed method isn't being triggered at all when i press a key.

What I've done to debug this is to first make sure that the JDialog can first of all be focusable so it can receive key events from the keyboard. I did that with this line of

System.out.println(myDialog.getFocusableWindowState());

and what I got on the console was true. Next I made sure that the key listener was being set. I did that with

 System.out.println( myDialog.getKeyListeners());

and this printed out

[Ljava.awt.event.KeyListener;@350b914b

which I assumed was a correct memory address for an object allocated from the heap.

I then checked out similar threads.

My issue couldn't be Jbutton listener isn't triggered, why? because the dialog box showed up and I made sure that the key listener was added with the print key listeners line. I couldn't use what the user said in Trying to use key Listener because I need to listen for the key press and use that key press later in my program. And this doesn't help either Why wont this KeyEvent work? because I need a general reaction to key presses to obtain which key was pressed.

I know that keyPressed isn't being executed because I put a breakpoint inside the method and this print statement

   System.out.println(KeyEvent.getKeyText(e.getKeyCode()));  

wasn't printing anything on the console.

Does anyone know how i can fix this issue?

Answer 1

You are adding the KeyListener to the dialog created by the JOptionPane.

However, focus is on the JButton on the dialog. KeyEvents are only dispatched to the component with focus so your key listener code is never invoked.

Why are you trying to listen for any key to close the dialog? The is NOT user friendly. The user does not know that is the way to close the dialog since this is not a standard UI convention. The user should click on the button to close the dialog.

If you really do need to listen to any key pressed while the dialog is open then check out Global Event Listeners which shows how you can use an AWTEventListener to listen for any key event regardless of which component has focus.

Answer 2

Having dealt with very similar issues, I encourage people who want to add listeners to the components of their JDialog to follow the approach shown here. It allows for more control over the components.

The following example demonstrates a custom dialog that validates the user's input each time the text changes using a KeyListener.

public class DialogWithListener extends JDialog {
    private JTextField textField = new JTextField();
    private boolean userPressedOk = false;

    /**
     * Creates a dialog that lets the user enter text in a text field.
     * <p>
     * Each time the user presses a key, the text is validated using the
     * {@link Predicate}s in {@code predsAndMsgs}. If the text doesn't satisfy
     * all predicates, the dialog shows the message associated with the first
     * unsatisfied predicate.
     * 
     * @param predsAndMsgs
     *            a map from {@link Predicate}s to the messages we'll show to
     *            users if the text they entered doesn't satisfy the predicates
     */
    public DialogWithListener(Map<Predicate<String>, String> predsAndMsgs) {

        JLabel textFieldLabel = new JLabel("Enter text:");

        // Show this if the text the user entered satisfies our predicates
        String okText = "All good";

        JLabel statusLabel = new JLabel(okText);

        Object[] paneContent = { textFieldLabel, textField, statusLabel };

        JButton okButton = new JButton("OK");
        okButton.addActionListener(e -> {
            userPressedOk = true;
            setVisible(false);
        });

        Object[] options = { okButton };
        JOptionPane optionPane = new JOptionPane(paneContent,
                JOptionPane.QUESTION_MESSAGE, JOptionPane.DEFAULT_OPTION, null,
                options);

        getContentPane().add(optionPane);
        setLocationRelativeTo(optionPane.getParent());

        setFocusTo(textField);

        // Check the user input each time a key is released
        textField.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent event) {
                validate(predsAndMsgs, textField.getText(), okText,
                        statusLabel, okButton);
            }
        });

        setModal(true);
        setResizable(false);

        pack();
    }

    /**
     * Validates the {@code textToValidate}.
     * <p>
     * The {@link Predicate}s in {@link predsAndMsgs} determine whether the text
     * is valid. If the text is invalid, we show the message that is associated
     * with the predicate and disable this dialog's OK button.
     * 
     * @param predsAndMsgs
     *            a map from {@link Predicate}s that must hold for the
     *            {@code textToValidate} to the messages we'll show to the user
     *            if a predicate is not satisfied.
     * @param textToValidate
     *            we validate this text against the {@link Predicate}s in
     *            {@link predsAndMsgs}
     * @param okText
     *            this text is shown if the {@code textToValidate} satisfies all
     *            predicates
     * @param statusLabel
     *            a {@link JLabel} that either shows the {@link okText} or the
     *            message of the first predicate that doesn't hold true for the
     *            {@link textToValidate}
     * @param okButton
     *            we enable and disable this button depending on whether the
     *            {@link textToValidate} is valid
     */
    private void validate(Map<Predicate<String>, String> predsAndMsgs,
            String textToValidate, String okText, JLabel statusLabel,
            JButton okButton) {
        // Get the first predicate that the text to validate doesn't satisfy
        Optional<Predicate<String>> unsatisfiedPredMaybe = predsAndMsgs
                .keySet().stream().filter(pred -> !pred.test(textToValidate))
                .findFirst();
        // At least one predicate was not satisfied
        if (unsatisfiedPredMaybe.isPresent()) {
            // Tell the user the text they entered can't be accepted
            String msg = predsAndMsgs.get(unsatisfiedPredMaybe.get());
            statusLabel.setText(msg);
            okButton.setEnabled(false);
        } else {
            statusLabel.setText(okText);
            okButton.setEnabled(true);
        }
        pack();
    }

    private void setFocusTo(JComponent comp) {
        addComponentListener(new ComponentAdapter() {
            @Override
            public void componentShown(ComponentEvent ce) {
                comp.requestFocusInWindow();
            }
        });
    }

    public Optional<String> display() {
        userPressedOk = false;
        // Because the dialog is modal it will block here
        setVisible(true);
        String dialogResult = null;
        if (userPressedOk) {
            dialogResult = textField.getText();
        }
        return Optional.ofNullable(dialogResult);
    }
}

And this is how you create and show the dialog:

public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
        @Override
        public void run() {
            try {
                UIManager.setLookAndFeel(UIManager
                        .getSystemLookAndFeelClassName());
            } catch (ClassNotFoundException | InstantiationException
                    | IllegalAccessException
                    | UnsupportedLookAndFeelException e) {
                e.printStackTrace();
            }
            createAndShowGUI();
        }
    });
}

private static void createAndShowGUI() {
    JFrame frame = new JFrame();
    JButton showDialogButton = new JButton("Show Dialog");

    // Define the predicates that the user entered-text should satisfy and
    // the messages shown to the user if it doesn't
    Map<Predicate<String>, String> predicatesAndMessages = new HashMap<>();
    Predicate<String> dontMentionHisName = text -> !text
            .contains("Voldemort");
    predicatesAndMessages.put(dontMentionHisName,
            "Sssh! You can't say that!");

    DialogWithListener dialog = new DialogWithListener(
            predicatesAndMessages);
    dialog.setTitle("My dialog");
    showDialogButton.addActionListener(e -> dialog.display().ifPresent(
            userText -> System.out.println(userText)));

    frame.getContentPane().add(showDialogButton);

    frame.pack();
    frame.setVisible(true);
}