Key-Event Handling

This section presents the KeyListener interface for handling key events. Key events are generated when keys on the keyboard are pressed and released. A class that implements KeyListener must provide declarations for methods keyPressed, keyReleased and keyTyped, each of which receives a KeyEvent as its argument. Class KeyEvent is a subclass of InputEvent. Method keyPressed is called in response to pressing any key. Method keyTyped is called in response to pressing any key that is not an action key. (The action keys are any arrow key, Home, End, Page Up, Page Down, any function key, Num Lock, Print Screen, Scroll Lock, Caps Lock and Pause.) Method keyReleased is called when the key is released after any keyPressed or keyTyped event.

The application of Fig. 11.36 and Fig. 11.37 demonstrates the KeyListener methods. Class KeyDemo implements the KeyListener interface, so all three methods are declared in the application.

Figure 11.36. Key event handling.

(This item is displayed on pages 564 - 565 in the print version)

 1 // Fig. 11.36: KeyDemoFrame.java
 2 // Demonstrating keystroke events.
 3 import java.awt.Color;
 4 import java.awt.event.KeyListener;
 5 import java.awt.event.KeyEvent;
 6 import javax.swing.JFrame;
 7 import javax.swing.JTextArea;
 8
 9 public class KeyDemoFrame extends JFrame implements KeyListener
10 {
11 private String line1 = ""; // first line of textarea
12 private String line2 = ""; // second line of textarea
13 private String line3 = ""; // third line of textarea
14 private JTextArea textArea; // textarea to display output
15
16 // KeyDemoFrame constructor
17 public KeyDemoFrame()
18 {
19 super( "Demonstrating Keystroke Events" );
20
21 textArea = new JTextArea( 10, 15 ); // set up JTextArea
22 textArea.setText( "Press any key on the keyboard..." );
23 textArea.setEnabled( false ); // disable textarea
24 textArea.setDisabledTextColor( Color.BLACK ); // set text color
25 add( textArea ); // add textarea to JFrame
26
27 addKeyListener( this ); // allow frame to process key events
28 } // end KeyDemoFrame constructor
29
30 // handle press of any key
31 public void keyPressed( KeyEvent event )
32 {
33 line1 = String.format( "Key pressed: %s",
34 event.getKeyText( event.getKeyCode() ) ); // output pressed key
35 setLines2and3( event ); // set output lines two and three
36 } // end method keyPressed
37
38 // handle release of any key
39 public void keyReleased( KeyEvent event )
40 {
41 line1 = String.format( "Key released: %s",
42 event.getKeyText( event.getKeyCode() ) ); // output released key
43 setLines2and3( event ); // set output lines two and three
44 } // end method keyReleased
45
46 // handle press of an action key
47 public void keyTyped( KeyEvent event )
48 {
49 line1 = String.format( "Key typed: %s", event.getKeyChar() );
50 setLines2and3( event ); // set output lines two and three
51 } // end method keyTyped
52
53 // set second and third lines of output
54 private void setLines2and3( KeyEvent event )
55 {
56 line2 = String.format( "This key is %san action key",
57 ( event.isActionKey() ? "" : "not " ) );
58
59 String temp = event.getKeyModifiersText( event.getModifiers() );
60
61 line3 = String.format( "Modifier keys pressed: %s",
62 ( temp.equals( "" ) ? "none" : temp ) ); // output modifiers
63
64 textArea.setText( String.format( "%s
%s
%s
",
65 line1, line2, line3 ) ); // output three lines of text
66 } // end method setLines2and3
67 } // end class KeyDemoFrame

Figure 11.37. Test class for KeyDemoFrame.

(This item is displayed on pages 565 - 566 in the print version)

 1 // Fig. 11.37: KeyDemo.java
 2 // Testing KeyDemoFrame.
 3 import javax.swing.JFrame;
 4
 5 public class KeyDemo
 6 {
 7 public static void main( String args[] )
 8 {
 9 KeyDemoFrame keyDemoFrame = new KeyDemoFrame();
10 keyDemoFrame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 keyDemoFrame.setSize( 350, 100 ); // set frame size
12 keyDemoFrame.setVisible( true ); // display frame
13 } // end main
14 } // end class KeyDemo

 

The constructor (Fig. 11.36, lines 1728) registers the application to handle its own key events by using method addKeyListener at line 27. Method addKeyListener is declared in class Component, so every subclass of Component can notify KeyListener objects of key events for that Component.

At line 25, the constructor adds JTextArea textArea (where the application's output is displayed) to the JFrame. Notice in the screen captures that textArea occupies the entire window. This is due to the JFrame's default BorderLayout (discussed in Section 11.17.2 and demonstrated in Fig. 11.41). When a single Component is added to a BorderLayout, the Component occupies the entire Container. Note that line 24 uses method setDisabledTextColor to change the color of the text in the text area to black.

Methods keyPressed (lines 3136) and keyReleased (lines 3944) use KeyEvent method getKeyCode to get the virtual key code of the key that was pressed. Class KeyEvent maintains a set of constantsthe virtual key-code constantsthat represents every key on the keyboard. These constants can be compared with the return value of getKeyCode to test for individual keys on the keyboard. The value returned by getKeyCode is passed to KeyEvent method getKeyText, which returns a string containing the name of the key that was pressed. For a complete list of virtual key constants, see the on-line documentation for class KeyEvent (package java.awt.event). Method keyTyped (lines 4751) uses KeyEvent method getKeyChar to get the Unicode value of the character typed.

All three event-handling methods finish by calling method setLines2and3 (lines 5466) and passing it the KeyEvent object. This method uses KeyEvent method isActionKey (line 57) to determine whether the key in the event was an action key. Also, InputEvent method getModifiers is called (line 59) to determine whether any modifier keys (such as Shift, Alt and Ctrl ) were pressed when the key event occurred. The result of this method is passed to KeyEvent method getKeyModifiersText, which produces a string containing the names of the pressed modifier keys.

[Note: If you need to test for a specific key on the keyboard, class KeyEvent provides a key constant for every key on the keyboard. These constants can be used from the key event handlers to determine whether a particular key was pressed. Also, to determine whether the Alt, Ctrl, Meta and Shift keys are pressed individually, InputEvent methods isAltDown, isControlDown, isMetaDown and isShiftDown each return a boolean indicating if the particular key was pressed during the key event.]