JSpinner and KeyListener: not working

[David A. Smith]

I've created a number-spinner class which should allow the user to press the + or - keys to increment or decrement the value. This is in addition to the normal up and down arrows on the control. (The idea is to have - another - keyboard control for changing the value.)

I've tried several variations, but can't seem to get the key handler to even be invoked. I've searched in this forum and elsewhere and have found a couple of similar descriptions, with responses like "oh yeah, it works now" (without much substance). Unfortunately, I still haven't reached that "oh yeah" part yet. Any ideas?

Thanks in advance...

I've extracted everything down to the smallest possible (and still broken) stand-alone example. Here's the code:

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

import javax.swing.JFrame;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerNumberModel;

/**
 * This class *should* allow typing + or - to increment or decrement spinner
 * values (by setting up a key handler).  But, it's not working; it's foobar'ed.
 * (Hence the class name...)
 */
public class foobar extends JSpinner {
   public foobar( int min, int max ) {
      model = new RolloverModel( 0, min, max, 1 ); // start, min, max, step
      setModel( model );
      JTextField tf = ((JSpinner.DefaultEditor)getEditor()).getTextField();
      tf.addKeyListener( new KeyHandler() ); // Handler gets added here
   }

   private class RolloverModel extends SpinnerNumberModel {
      public RolloverModel( int initialValue, int minimumValue, int maximumValue, int stepSize ) {
         super( initialValue, minimumValue, maximumValue, stepSize );
      }

      public Object getNextValue() {
         Object obj = super.getNextValue();
         if ( obj == null ) obj = getMinimum();
         return obj;
      }

      public Object getPreviousValue() {
         Object obj = super.getPreviousValue();
         if ( obj == null ) obj = getMaximum();
         return obj;
      }
   }

   private class KeyHandler implements KeyListener {
      public void keyReleased( KeyEvent e ) {
         System.out.println( "hello?" ); // This never appears...
         char c = e.getKeyChar();
         if ( c == '+' || c == '=' ) model.setValue( model.getNextValue() );
         if ( c == '-' ) model.setValue( model.getPreviousValue() );
      }
      public void keyPressed( KeyEvent e ) { }
      public void keyTyped( KeyEvent e ) { }
   }

   private RolloverModel model;
}

class test extends JFrame {
   public test() {
      super( "Spinner Test" );
      setSize( 250, 100 );
      setDefaultCloseOperation( EXIT_ON_CLOSE );

      Container c = getContentPane();
      c.setLayout( new FlowLayout() );
      c.add( new RolloverIntSpinner(1,4) );

      setVisible( true );
   }

   public static void main( String[] args ) {
      new test();
   }
}

[Darryl Burke]

This makes use of the key bindings of the arrow keys and binds them to the numpad + and - keys. It's also necessary to consume the key typed events so that they aren't echoed in the spinner's editor.

I prefer to not extend Swing components (any class, really!) except where absolutely necessary, and favor a static utility method that returns a customized component.

import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import javax.swing.*;

public class PlusMinusSpinner {

  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {

      @Override
      public void run() {
        makeUI();
      }
    });
  }

  public static void makeUI() {
    JSpinner spinner = getPlusMinusSpinner();
    JFrame frame = new JFrame();
    frame.add(spinner);

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.pack();
    frame.setLocationRelativeTo(null);
    frame.setVisible(true);
  }

  public static JSpinner getPlusMinusSpinner() {
    JSpinner spinner = new JSpinner();

    InputMap inputMap = spinner.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
    Object plusKey = inputMap.get(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0));
    inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ADD, 0), plusKey);

    Object minusKey = inputMap.get(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0));
    inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SUBTRACT, 0), minusKey);

    final JTextField textField = ((JSpinner.DefaultEditor) spinner.getEditor()).getTextField();
    textField.addKeyListener(new KeyAdapter() {

      @Override
      public void keyTyped(KeyEvent e) {
        if (e.getKeyChar() == '+' || e.getKeyChar() == '-') {
          e.consume();
        }
      }
    });
    return spinner;
  }
}

edit: I'm not sure whether it's documented that listeners are invoked in the reverse of the order in which they are added, but AFAIK that's the behavior for all listeners added to Swing components, and this solution depends on it so as to consume the key typed events before they are processed by the UI-installed handler.

[David A. Smith]

Very interesting...! Thanks for your reply. I'm not familiar with the particular technique, so I'll have to play with it a bit.

Also, thanks for your comment on the order of listeners. I had wondered about that, but hadn't watched it that closely. I had another problem where I was trying to temporarily take listeners out of the loop so I could programatically set values without firing events to the listeners, but that's a different topic.

Dave.

[Darryl Burke]

I'm not familiar with the particular technique, so I'll have to play with it a bit.

How to use Key Bindings