Events to detect change in physical keyboard key state

Question

I would like my application to respond in one way to a keyboard key being pressed, and then another way to the key being released. That is, I want my application to be able to reflect the actual physical state of the keyboard key.
The obvious use of the (several) Java API's for keyboard events rapidly fires repeated KEY_PRESSED and KEY_RELEASED events if the key is held down for any time. This unfortunately obscures the actual state of the physical key (how do you know which was the last KEY_RELEASED?)
Is it possible to turn off the key repeat feature, just for component, say?
This would seem to be an obvious thing to do, but I can't find sample code anywhere. The code I find in the Sun Java API manuals all shows the above problem with key repetition.
I would be also pleased to know that the solution of this problem is well known, on some FAQ or something, but I have looked through several FAQ's and searched this formum and have found nothing that helps. Also, I have had the misfortune of having to build messy and non-robust solutions for the equivalent problem in other development environments. I hope it is already there somewhere in Java and I'm just missing it.
Thanks!

Answer 1

"If two subsequent KEY_RELEASED and KEY_PRESSED
events have the same
timestamp, they are caused by autorepeat"
This sounds good. But unfortunately the repeated
KEY_RELEASED and KEY_PRESSED caused by key autorepeat
on my system (Linux, java 1.5.0_09) have
timestamps that increase with each repetition.I think this means only that the pair of pressed/release events have the
same timestamp, not that every such pair has the same timestamp.
That is, if you have the sequence PRESS,RELEASE,PRESS,RELEASE,
the first two would have the same timestamp, and then the second two
would have the same timestamp, but different than the first. Regardless,
I found that also to not be the case; the PRESS and RELEASE did not have
the same timestamp even between pairs.
That said, this seems to work on both Windows and Linux, with the caveat
that releases may lag.
import java.awt.event.*;
import java.util.HashMap;
import java.util.Map;
import javax.swing.*;
public class LinuxKeyTest extends JPanel implements KeyListener {
     int delay = 750; // Must be > than your 500ms start delay.
     int delayRepeat = 75; // Must be greater than keyboard repeat interval.
     Map timers = new HashMap();
     int m_keyCode = -1;
     public static void main( String[] args ) {
          Runnable doRun = new Runnable() {
               public void run() {
                    new LinuxKeyTest();
          SwingUtilities.invokeLater( doRun );
     public LinuxKeyTest() {
          JPanel panel = new JPanel();
          panel.setFocusable( true );
          panel.requestFocusInWindow();
          panel.addKeyListener( this );
          JFrame f = new JFrame();
          f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
          f.getContentPane().add( panel );
          f.setSize( 200, 100 );
          f.setLocation( 200, 200 );
          f.setVisible( true );
     public void keyPressed( KeyEvent e ) {
          int keyCode = e.getKeyCode();
          m_keyCode = keyCode;
          Integer timerKey = new Integer( keyCode );
          Timer timer = (Timer) timers.get( timerKey );
          if ( timer == null ) {
               KeyTimeout keyTimeout = new KeyTimeout( timerKey, e.getWhen() );
               timer = new Timer( delay, keyTimeout );
               timers.put( timerKey, timer );
               timer.start();
               pressed( keyCode );
          } else {
               ( (KeyTimeout) timer.getActionListeners()[0] ).setPressed( e.getWhen() );
               timer.restart();
     public void keyReleased( KeyEvent e ) {
          int keyCode = e.getKeyCode();
          Integer timerKey = new Integer( keyCode );
          Timer timer = (Timer) timers.get( timerKey );
          if ( timer != null ) {
               ( (KeyTimeout) timer.getActionListeners()[0] ).setReleased( e.getWhen() );
               timer.setInitialDelay( delayRepeat );
               m_keyCode = ( m_keyCode == keyCode ? -1 : keyCode );
          } else if ( m_keyCode != keyCode ) {
               released( keyCode );
     public void keyTyped( KeyEvent e ) {
     public void pressed( int keyCode ) {          
          System.out.println( keyCode + " pressed" );
     public void released( int keyCode ) {
          System.out.println( keyCode + " released" );
     public class KeyTimeout implements ActionListener {
          private Integer timerKey;
          private int keyCode;
          private long firstPressed;
          private long pressed;
          private long released;
          public KeyTimeout( Integer key, long time ) {
               this.timerKey = key;
               this.keyCode = timerKey.intValue();
               this.firstPressed = time;
               this.pressed = time;
               this.released = time;
          public void actionPerformed( ActionEvent e ) {
               if ( released != firstPressed && released != pressed ) {
                    released( keyCode );
                    stop();
               } else if ( m_keyCode != keyCode ) {
                    if ( m_keyCode == -1 ) {
                         released( keyCode );
                    stop();
          public void stop() {
               Timer timer = (Timer) timers.get( timerKey );
               timer.stop();
               timers.remove( timerKey );
          public void setPressed( long time ) {
               this.pressed = time;
          public void setReleased( long time ) {
               this.released = time;
}