Java Tutorial/Swing Event/KeyListener
Содержание
- 1 Demonstrates key events
- 2 Get key pressed as a key character (which is a Unicode character)
- 3 Get key pressed as a key code
- 4 Handling Key Presses
- 5 How to Write a Key Listener
- 6 KeyListener and KeyEvent
- 7 Listing the Key Bindings in a Component
- 8 Make the ENTER key act like the TAB key
- 9 Overriding Many Default Typed Key Bindings in a JTextComponent
- 10 Setting Focus Traversal Keys in a Component
- 11 The event IDs that the KeyEvent class defines
- 12 The KeyListener Interface
Demonstrates key events
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JTextField;
class MyKeyListener implements KeyListener {
public void keyTyped(KeyEvent e) {
char c = e.getKeyChar();
System.out.println("Key Typed: " + c);
}
public void keyPressed(KeyEvent e) {
char c = e.getKeyChar();
System.out.println("Key Pressed: " + c);
}
public void keyReleased(KeyEvent e) {
char c = e.getKeyChar();
System.out.println("Key Released: " + c);
}
}
public class KeyListenerDemo {
public static void main(String[] a) {
JFrame frame = new JFrame("Popup JComboBox");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTextField textField = new JTextField();
textField.addKeyListener(new MyKeyListener());
frame.add(textField);
frame.setSize(300, 200);
frame.setVisible(true);
}
}
Get key pressed as a key character (which is a Unicode character)
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class Main {
public static void main(String[] argv) throws Exception {
JTextField component = new JTextField();
component.addKeyListener(new MyKeyListener());
JFrame f = new JFrame();
f.add(component);
f.setSize(300, 300);
f.setVisible(true);
}
}
class MyKeyListener extends KeyAdapter {
public void keyPressed(KeyEvent evt) {
if (evt.getKeyChar() == "a") {
System.out.println("Check for key characters: " + evt.getKeyChar());
}
if (evt.getKeyCode() == KeyEvent.VK_HOME) {
System.out.println("Check for key codes: " + evt.getKeyCode());
}
}
}
Get key pressed as a key code
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class Main {
public static void main(String[] argv) throws Exception {
JTextField component = new JTextField();
component.addKeyListener(new MyKeyListener());
JFrame f = new JFrame();
f.add(component);
f.setSize(300, 300);
f.setVisible(true);
}
}
class MyKeyListener extends KeyAdapter {
public void keyPressed(KeyEvent evt) {
if (evt.getKeyChar() == "a") {
System.out.println("Check for key characters: " + evt.getKeyChar());
}
if (evt.getKeyCode() == KeyEvent.VK_HOME) {
System.out.println("Check for key codes: " + evt.getKeyCode());
}
}
}
Handling Key Presses
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class Main {
public static void main(String[] argv) throws Exception {
JTextField component = new JTextField();
component.addKeyListener(new MyKeyListener());
JFrame f = new JFrame();
f.add(component);
f.setSize(300, 300);
f.setVisible(true);
}
}
class MyKeyListener extends KeyAdapter {
public void keyPressed(KeyEvent evt) {
if (evt.getKeyChar() == "a") {
System.out.println("Check for key characters: " + evt.getKeyChar());
}
if (evt.getKeyCode() == KeyEvent.VK_HOME) {
System.out.println("Check for key codes: " + evt.getKeyCode());
}
}
}
How to Write a Key Listener
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class UsingKeyListener {
public static void main(String[] args) {
JFrame aWindow = new JFrame("This is the Window Title");
aWindow.setBounds(50, 100, 300, 300);
aWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JTextField typingArea = new JTextField(20);
typingArea.addKeyListener(new KeyListener() {
/** Handle the key typed event from the text field. */
public void keyTyped(KeyEvent e) {
displayInfo(e, "KEY TYPED: ");
}
/** Handle the key pressed event from the text field. */
public void keyPressed(KeyEvent e) {
displayInfo(e, "KEY PRESSED: ");
}
/** Handle the key released event from the text field. */
public void keyReleased(KeyEvent e) {
displayInfo(e, "KEY RELEASED: ");
}
protected void displayInfo(KeyEvent e, String s) {
String keyString, modString, tmpString, actionString, locationString;
// You should only rely on the key char if the event
// is a key typed event.
int id = e.getID();
if (id == KeyEvent.KEY_TYPED) {
char c = e.getKeyChar();
keyString = "key character = "" + c + """;
} else {
int keyCode = e.getKeyCode();
keyString = "key code = " + keyCode + " (" + KeyEvent.getKeyText(keyCode) + ")";
}
int modifiers = e.getModifiersEx();
modString = "modifiers = " + modifiers;
tmpString = KeyEvent.getModifiersExText(modifiers);
if (tmpString.length() > 0) {
modString += " (" + tmpString + ")";
} else {
modString += " (no modifiers)";
}
actionString = "action key? ";
if (e.isActionKey()) {
actionString += "YES";
} else {
actionString += "NO";
}
locationString = "key location: ";
int location = e.getKeyLocation();
if (location == KeyEvent.KEY_LOCATION_STANDARD) {
locationString += "standard";
} else if (location == KeyEvent.KEY_LOCATION_LEFT) {
locationString += "left";
} else if (location == KeyEvent.KEY_LOCATION_RIGHT) {
locationString += "right";
} else if (location == KeyEvent.KEY_LOCATION_NUMPAD) {
locationString += "numpad";
} else { // (location == KeyEvent.KEY_LOCATION_UNKNOWN)
locationString += "unknown";
}
System.out.println(keyString);
System.out.println(modString);
System.out.println(actionString);
System.out.println(locationString);
}
});
aWindow.add(typingArea);
aWindow.setVisible(true);
}
}
KeyListener and KeyEvent
/*
* Copyright (c) 1995 - 2008 Sun Microsystems, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of Sun Microsystems nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* KeyEventDemo
*/
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
public class KeyEventDemo extends JFrame implements KeyListener, ActionListener {
JTextArea displayArea;
JTextField typingArea;
static final String newline = System.getProperty("line.separator");
public static void main(String[] args) {
/* Use an appropriate Look and Feel */
try {
// UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
// UIManager.setLookAndFeel("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
} catch (UnsupportedLookAndFeelException ex) {
ex.printStackTrace();
} catch (IllegalAccessException ex) {
ex.printStackTrace();
} catch (InstantiationException ex) {
ex.printStackTrace();
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
/* Turn off metal"s use of bold fonts */
UIManager.put("swing.boldMetal", Boolean.FALSE);
// Schedule a job for event dispatch thread:
// creating and showing this application"s GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});
}
/**
* Create the GUI and show it. For thread safety, this method should be
* invoked from the event-dispatching thread.
*/
private static void createAndShowGUI() {
// Create and set up the window.
KeyEventDemo frame = new KeyEventDemo("KeyEventDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Set up the content pane.
frame.addComponentsToPane();
// Display the window.
frame.pack();
frame.setVisible(true);
}
private void addComponentsToPane() {
JButton button = new JButton("Clear");
button.addActionListener(this);
typingArea = new JTextField(20);
typingArea.addKeyListener(this);
// Uncomment this if you wish to turn off focus
// traversal. The focus subsystem consumes
// focus traversal keys, such as Tab and Shift Tab.
// If you uncomment the following line of code, this
// disables focus traversal and the Tab events will
// become available to the key event listener.
// typingArea.setFocusTraversalKeysEnabled(false);
displayArea = new JTextArea();
displayArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(displayArea);
scrollPane.setPreferredSize(new Dimension(375, 125));
getContentPane().add(typingArea, BorderLayout.PAGE_START);
getContentPane().add(scrollPane, BorderLayout.CENTER);
getContentPane().add(button, BorderLayout.PAGE_END);
}
public KeyEventDemo(String name) {
super(name);
}
/** Handle the key typed event from the text field. */
public void keyTyped(KeyEvent e) {
displayInfo(e, "KEY TYPED: ");
}
/** Handle the key pressed event from the text field. */
public void keyPressed(KeyEvent e) {
displayInfo(e, "KEY PRESSED: ");
}
/** Handle the key released event from the text field. */
public void keyReleased(KeyEvent e) {
displayInfo(e, "KEY RELEASED: ");
}
/** Handle the button click. */
public void actionPerformed(ActionEvent e) {
// Clear the text components.
displayArea.setText("");
typingArea.setText("");
// Return the focus to the typing area.
typingArea.requestFocusInWindow();
}
/*
* We have to jump through some hoops to avoid trying to print non-printing
* characters such as Shift. (Not only do they not print, but if you put them
* in a String, the characters afterward won"t show up in the text area.)
*/
private void displayInfo(KeyEvent e, String keyStatus) {
// You should only rely on the key char if the event
// is a key typed event.
int id = e.getID();
String keyString;
if (id == KeyEvent.KEY_TYPED) {
char c = e.getKeyChar();
keyString = "key character = "" + c + """;
} else {
int keyCode = e.getKeyCode();
keyString = "key code = " + keyCode + " (" + KeyEvent.getKeyText(keyCode)
+ ")";
}
int modifiersEx = e.getModifiersEx();
String modString = "extended modifiers = " + modifiersEx;
String tmpString = KeyEvent.getModifiersExText(modifiersEx);
if (tmpString.length() > 0) {
modString += " (" + tmpString + ")";
} else {
modString += " (no extended modifiers)";
}
String actionString = "action key? ";
if (e.isActionKey()) {
actionString += "YES";
} else {
actionString += "NO";
}
String locationString = "key location: ";
int location = e.getKeyLocation();
if (location == KeyEvent.KEY_LOCATION_STANDARD) {
locationString += "standard";
} else if (location == KeyEvent.KEY_LOCATION_LEFT) {
locationString += "left";
} else if (location == KeyEvent.KEY_LOCATION_RIGHT) {
locationString += "right";
} else if (location == KeyEvent.KEY_LOCATION_NUMPAD) {
locationString += "numpad";
} else { // (location == KeyEvent.KEY_LOCATION_UNKNOWN)
locationString += "unknown";
}
displayArea.append(keyStatus + newline + " " + keyString + newline
+ " " + modString + newline + " " + actionString + newline
+ " " + locationString + newline);
displayArea.setCaretPosition(displayArea.getDocument().getLength());
}
}
Listing the Key Bindings in a Component
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import javax.swing.Action;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.KeyStroke;
public class Main {
public static void main(String[] argv) throws Exception {
JButton component = new JButton("button");
InputMap map = component.getInputMap(JComponent.WHEN_FOCUSED);
list(map, map.keys());
list(map, map.allKeys());
}
static void list(InputMap map, KeyStroke[] keys) {
if (keys == null) {
return;
}
for (int i = 0; i < keys.length; i++) {
keyStroke2String(keys[i]);
while (map.get(keys[i]) == null) {
map = map.getParent();
}
if (map.get(keys[i]) instanceof String) {
String actionName = (String) map.get(keys[i]);
System.out.println(actionName);
} else {
Action action = (Action) map.get(keys[i]);
System.out.println(action);
}
}
}
static void keyStroke2String(KeyStroke key) {
int m = key.getModifiers();
if ((m & (InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK)) != 0) {
System.out.println("shift ");
}
if ((m & (InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK)) != 0) {
System.out.println("ctrl ");
}
if ((m & (InputEvent.META_DOWN_MASK | InputEvent.META_MASK)) != 0) {
System.out.println("meta ");
}
if ((m & (InputEvent.ALT_DOWN_MASK | InputEvent.ALT_MASK)) != 0) {
System.out.println("alt ");
}
if ((m & (InputEvent.BUTTON1_DOWN_MASK | InputEvent.BUTTON1_MASK)) != 0) {
System.out.println("button1 ");
}
if ((m & (InputEvent.BUTTON2_DOWN_MASK | InputEvent.BUTTON2_MASK)) != 0) {
System.out.println("button2 ");
}
if ((m & (InputEvent.BUTTON3_DOWN_MASK | InputEvent.BUTTON3_MASK)) != 0) {
System.out.println("button3 ");
}
switch (key.getKeyEventType()) {
case KeyEvent.KEY_TYPED:
System.out.println("typed ");
System.out.println(key.getKeyChar() + " ");
break;
case KeyEvent.KEY_PRESSED:
System.out.println("pressed ");
System.out.println(getKeyText(key.getKeyCode()) + " ");
break;
case KeyEvent.KEY_RELEASED:
System.out.println("released ");
System.out.println(getKeyText(key.getKeyCode()) + " ");
break;
default:
System.out.println("unknown-event-type ");
break;
}
}
static String getKeyText(int keyCode) {
if (keyCode >= KeyEvent.VK_0 && keyCode <= KeyEvent.VK_9 || keyCode >= KeyEvent.VK_A
&& keyCode <= KeyEvent.VK_Z) {
return String.valueOf((char) keyCode);
}
switch (keyCode) {
case KeyEvent.VK_COMMA:
return "COMMA";
case KeyEvent.VK_PERIOD:
return "PERIOD";
case KeyEvent.VK_SLASH:
return "SLASH";
case KeyEvent.VK_SEMICOLON:
return "SEMICOLON";
case KeyEvent.VK_EQUALS:
return "EQUALS";
case KeyEvent.VK_OPEN_BRACKET:
return "OPEN_BRACKET";
case KeyEvent.VK_BACK_SLASH:
return "BACK_SLASH";
case KeyEvent.VK_CLOSE_BRACKET:
return "CLOSE_BRACKET";
case KeyEvent.VK_ENTER:
return "ENTER";
case KeyEvent.VK_BACK_SPACE:
return "BACK_SPACE";
case KeyEvent.VK_TAB:
return "TAB";
case KeyEvent.VK_CANCEL:
return "CANCEL";
case KeyEvent.VK_CLEAR:
return "CLEAR";
case KeyEvent.VK_SHIFT:
return "SHIFT";
case KeyEvent.VK_CONTROL:
return "CONTROL";
case KeyEvent.VK_ALT:
return "ALT";
case KeyEvent.VK_PAUSE:
return "PAUSE";
case KeyEvent.VK_CAPS_LOCK:
return "CAPS_LOCK";
case KeyEvent.VK_ESCAPE:
return "ESCAPE";
case KeyEvent.VK_SPACE:
return "SPACE";
case KeyEvent.VK_PAGE_UP:
return "PAGE_UP";
case KeyEvent.VK_PAGE_DOWN:
return "PAGE_DOWN";
case KeyEvent.VK_END:
return "END";
case KeyEvent.VK_HOME:
return "HOME";
case KeyEvent.VK_LEFT:
return "LEFT";
case KeyEvent.VK_UP:
return "UP";
case KeyEvent.VK_RIGHT:
return "RIGHT";
case KeyEvent.VK_DOWN:
return "DOWN";
// numpad numeric keys handled below
case KeyEvent.VK_MULTIPLY:
return "MULTIPLY";
case KeyEvent.VK_ADD:
return "ADD";
case KeyEvent.VK_SEPARATOR:
return "SEPARATOR";
case KeyEvent.VK_SUBTRACT:
return "SUBTRACT";
case KeyEvent.VK_DECIMAL:
return "DECIMAL";
case KeyEvent.VK_DIVIDE:
return "DIVIDE";
case KeyEvent.VK_DELETE:
return "DELETE";
case KeyEvent.VK_NUM_LOCK:
return "NUM_LOCK";
case KeyEvent.VK_SCROLL_LOCK:
return "SCROLL_LOCK";
case KeyEvent.VK_F1:
return "F1";
case KeyEvent.VK_F2:
return "F2";
case KeyEvent.VK_F3:
return "F3";
case KeyEvent.VK_F4:
return "F4";
case KeyEvent.VK_F5:
return "F5";
case KeyEvent.VK_F6:
return "F6";
case KeyEvent.VK_F7:
return "F7";
case KeyEvent.VK_F8:
return "F8";
case KeyEvent.VK_F9:
return "F9";
case KeyEvent.VK_F10:
return "F10";
case KeyEvent.VK_F11:
return "F11";
case KeyEvent.VK_F12:
return "F12";
case KeyEvent.VK_F13:
return "F13";
case KeyEvent.VK_F14:
return "F14";
case KeyEvent.VK_F15:
return "F15";
case KeyEvent.VK_F16:
return "F16";
case KeyEvent.VK_F17:
return "F17";
case KeyEvent.VK_F18:
return "F18";
case KeyEvent.VK_F19:
return "F19";
case KeyEvent.VK_F20:
return "F20";
case KeyEvent.VK_F21:
return "F21";
case KeyEvent.VK_F22:
return "F22";
case KeyEvent.VK_F23:
return "F23";
case KeyEvent.VK_F24:
return "F24";
case KeyEvent.VK_PRINTSCREEN:
return "PRINTSCREEN";
case KeyEvent.VK_INSERT:
return "INSERT";
case KeyEvent.VK_HELP:
return "HELP";
case KeyEvent.VK_META:
return "META";
case KeyEvent.VK_BACK_QUOTE:
return "BACK_QUOTE";
case KeyEvent.VK_QUOTE:
return "QUOTE";
case KeyEvent.VK_KP_UP:
return "KP_UP";
case KeyEvent.VK_KP_DOWN:
return "KP_DOWN";
case KeyEvent.VK_KP_LEFT:
return "KP_LEFT";
case KeyEvent.VK_KP_RIGHT:
return "KP_RIGHT";
case KeyEvent.VK_DEAD_GRAVE:
return "DEAD_GRAVE";
case KeyEvent.VK_DEAD_ACUTE:
return "DEAD_ACUTE";
case KeyEvent.VK_DEAD_CIRCUMFLEX:
return "DEAD_CIRCUMFLEX";
case KeyEvent.VK_DEAD_TILDE:
return "DEAD_TILDE";
case KeyEvent.VK_DEAD_MACRON:
return "DEAD_MACRON";
case KeyEvent.VK_DEAD_BREVE:
return "DEAD_BREVE";
case KeyEvent.VK_DEAD_ABOVEDOT:
return "DEAD_ABOVEDOT";
case KeyEvent.VK_DEAD_DIAERESIS:
return "DEAD_DIAERESIS";
case KeyEvent.VK_DEAD_ABOVERING:
return "DEAD_ABOVERING";
case KeyEvent.VK_DEAD_DOUBLEACUTE:
return "DEAD_DOUBLEACUTE";
case KeyEvent.VK_DEAD_CARON:
return "DEAD_CARON";
case KeyEvent.VK_DEAD_CEDILLA:
return "DEAD_CEDILLA";
case KeyEvent.VK_DEAD_OGONEK:
return "DEAD_OGONEK";
case KeyEvent.VK_DEAD_IOTA:
return "DEAD_IOTA";
case KeyEvent.VK_DEAD_VOICED_SOUND:
return "DEAD_VOICED_SOUND";
case KeyEvent.VK_DEAD_SEMIVOICED_SOUND:
return "DEAD_SEMIVOICED_SOUND";
case KeyEvent.VK_AMPERSAND:
return "AMPERSAND";
case KeyEvent.VK_ASTERISK:
return "ASTERISK";
case KeyEvent.VK_QUOTEDBL:
return "QUOTEDBL";
case KeyEvent.VK_LESS:
return "LESS";
case KeyEvent.VK_GREATER:
return "GREATER";
case KeyEvent.VK_BRACELEFT:
return "BRACELEFT";
case KeyEvent.VK_BRACERIGHT:
return "BRACERIGHT";
case KeyEvent.VK_AT:
return "AT";
case KeyEvent.VK_COLON:
return "COLON";
case KeyEvent.VK_CIRCUMFLEX:
return "CIRCUMFLEX";
case KeyEvent.VK_DOLLAR:
return "DOLLAR";
case KeyEvent.VK_EURO_SIGN:
return "EURO_SIGN";
case KeyEvent.VK_EXCLAMATION_MARK:
return "EXCLAMATION_MARK";
case KeyEvent.VK_INVERTED_EXCLAMATION_MARK:
return "INVERTED_EXCLAMATION_MARK";
case KeyEvent.VK_LEFT_PARENTHESIS:
return "LEFT_PARENTHESIS";
case KeyEvent.VK_NUMBER_SIGN:
return "NUMBER_SIGN";
case KeyEvent.VK_MINUS:
return "MINUS";
case KeyEvent.VK_PLUS:
return "PLUS";
case KeyEvent.VK_RIGHT_PARENTHESIS:
return "RIGHT_PARENTHESIS";
case KeyEvent.VK_UNDERSCORE:
return "UNDERSCORE";
case KeyEvent.VK_FINAL:
return "FINAL";
case KeyEvent.VK_CONVERT:
return "CONVERT";
case KeyEvent.VK_NONCONVERT:
return "NONCONVERT";
case KeyEvent.VK_ACCEPT:
return "ACCEPT";
case KeyEvent.VK_MODECHANGE:
return "MODECHANGE";
case KeyEvent.VK_KANA:
return "KANA";
case KeyEvent.VK_KANJI:
return "KANJI";
case KeyEvent.VK_ALPHANUMERIC:
return "ALPHANUMERIC";
case KeyEvent.VK_KATAKANA:
return "KATAKANA";
case KeyEvent.VK_HIRAGANA:
return "HIRAGANA";
case KeyEvent.VK_FULL_WIDTH:
return "FULL_WIDTH";
case KeyEvent.VK_HALF_WIDTH:
return "HALF_WIDTH";
case KeyEvent.VK_ROMAN_CHARACTERS:
return "ROMAN_CHARACTERS";
case KeyEvent.VK_ALL_CANDIDATES:
return "ALL_CANDIDATES";
case KeyEvent.VK_PREVIOUS_CANDIDATE:
return "PREVIOUS_CANDIDATE";
case KeyEvent.VK_CODE_INPUT:
return "CODE_INPUT";
case KeyEvent.VK_JAPANESE_KATAKANA:
return "JAPANESE_KATAKANA";
case KeyEvent.VK_JAPANESE_HIRAGANA:
return "JAPANESE_HIRAGANA";
case KeyEvent.VK_JAPANESE_ROMAN:
return "JAPANESE_ROMAN";
case KeyEvent.VK_KANA_LOCK:
return "KANA_LOCK";
case KeyEvent.VK_INPUT_METHOD_ON_OFF:
return "INPUT_METHOD_ON_OFF";
case KeyEvent.VK_AGAIN:
return "AGAIN";
case KeyEvent.VK_UNDO:
return "UNDO";
case KeyEvent.VK_COPY:
return "COPY";
case KeyEvent.VK_PASTE:
return "PASTE";
case KeyEvent.VK_CUT:
return "CUT";
case KeyEvent.VK_FIND:
return "FIND";
case KeyEvent.VK_PROPS:
return "PROPS";
case KeyEvent.VK_STOP:
return "STOP";
case KeyEvent.VK_COMPOSE:
return "COMPOSE";
case KeyEvent.VK_ALT_GRAPH:
return "ALT_GRAPH";
}
if (keyCode >= KeyEvent.VK_NUMPAD0 && keyCode <= KeyEvent.VK_NUMPAD9) {
char c = (char) (keyCode - KeyEvent.VK_NUMPAD0 + "0");
return "NUMPAD" + c;
}
return "unknown(0x" + Integer.toString(keyCode, 16) + ")";
}
}
Make the ENTER key act like the TAB key
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JTextField;
class MyTextField extends JTextField {
MyTextField(int len) {
super(len);
addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
int key = evt.getKeyCode();
if (key == KeyEvent.VK_ENTER)
transferFocus();
}
});
}
}
Overriding Many Default Typed Key Bindings in a JTextComponent
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.text.BadLocationException;
import javax.swing.text.JTextComponent;
class MyKeyListener extends KeyAdapter {
public void keyTyped(KeyEvent evt) {
JTextComponent c = (JTextComponent) evt.getSource();
char ch = evt.getKeyChar();
if (Character.isLowerCase(ch) == false) {
return;
}
try {
c.getDocument().insertString(c.getCaretPosition(), "" + Character.toUpperCase(ch), null);
evt.consume();
} catch (BadLocationException e) {
}
}
}
public class Main {
public static void main(String[] argv) throws Exception {
JTextField component = new JTextField();
component.addKeyListener(new MyKeyListener());
JFrame f = new JFrame();
f.setSize(300, 300);
f.setVisible(true);
}
}
Setting Focus Traversal Keys in a Component
import java.awt.KeyboardFocusManager;
import java.util.HashSet;
import java.util.Set;
import javax.swing.JButton;
import javax.swing.KeyStroke;
public class Main {
public static void main(String[] argv) throws Exception {
JButton component = new JButton("a");
Set set = new HashSet(component
.getFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS));
set.add(KeyStroke.getKeyStroke("F2"));
component.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, set);
}
}
The event IDs that the KeyEvent class defines
- KEY_TYPED
- KEY_PRESSED
- KEY_RELEASED
The KeyListener Interface
This interface defines methods to respond to events arising when a key on the keyboard is pressed or released.
Defined MethodsDescriptionkeyTyped(KeyEvent e)Called when a key on the keyboard is pressed and then releasedkeyPressed(KeyEvent e)Called when a key on the keyboard is pressedkeyReleased(KeyEvent e)Called when a key on the keyboard is released
