Java/Swing JFC/Actions

Action Demo

 
/* From http://java.sun.ru/docs/books/tutorial/index.html */
/*
 * Copyright (c) 2006 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:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution 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, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
/* Uses actions with a tool bar and a menu. */
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JToolBar;
public class ActionDemo extends JFrame {
  protected JTextArea textArea;
  protected String newline = "\n";
  protected Action leftAction;
  protected Action middleAction;
  protected Action rightAction;
  public ActionDemo() {
    //Do frame stuff.
    super("ActionDemo");
    addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });
    //Create the toolbar and menu.
    JToolBar toolBar = new JToolBar();
    JMenu mainMenu = new JMenu("Menu");
    createActionComponents(toolBar, mainMenu);
    //Create the text area used for output.
    textArea = new JTextArea(5, 30);
    JScrollPane scrollPane = new JScrollPane(textArea);
    //Lay out the content pane.
    JPanel contentPane = new JPanel();
    contentPane.setLayout(new BorderLayout());
    contentPane.setPreferredSize(new Dimension(400, 150));
    contentPane.add(toolBar, BorderLayout.SOUTH);
    contentPane.add(scrollPane, BorderLayout.CENTER);
    setContentPane(contentPane);
    //Set up the menu bar.
    JMenuBar mb = new JMenuBar();
    mb.add(mainMenu);
    mb.add(createAbleMenu());
    setJMenuBar(mb);
  }
  protected void createActionComponents(JToolBar toolBar, JMenu mainMenu) {
    JButton button = null;
    JMenuItem menuItem = null;
    //first button and menu item
    leftAction = new AbstractAction("Go left", new ImageIcon(
        "images/left.gif")) {
      public void actionPerformed(ActionEvent e) {
        displayResult("Action for first button/menu item", e);
      }
    };
    button = toolBar.add(leftAction);
    button.setText(""); //an icon-only button
    button.setToolTipText("This is the left button");
    menuItem = mainMenu.add(leftAction);
    menuItem.setIcon(null); //arbitrarily chose not to use icon in menu
    //second button and menu item
    middleAction = new AbstractAction("Do something", new ImageIcon(
        "images/middle.gif")) {
      public void actionPerformed(ActionEvent e) {
        displayResult("Action for second button/menu item", e);
      }
    };
    button = toolBar.add(middleAction);
    button.setText("");
    button.setToolTipText("This is the middle button");
    menuItem = mainMenu.add(middleAction);
    menuItem.setIcon(null); //arbitrarily chose not to use icon in menu
    //third button and menu item
    rightAction = new AbstractAction("Go right", new ImageIcon(
        "images/right.gif")) {
      public void actionPerformed(ActionEvent e) {
        displayResult("Action for third button/menu item", e);
      }
    };
    button = toolBar.add(rightAction);
    button.setText("");
    button.setToolTipText("This is the right button");
    menuItem = mainMenu.add(rightAction);
    menuItem.setIcon(null); //arbitrarily chose not to use icon in menu
  }
  protected JMenu createAbleMenu() {
    JMenu ableMenu = new JMenu("Action State");
    JCheckBoxMenuItem cbmi = null;
    cbmi = new JCheckBoxMenuItem("First action enabled");
    cbmi.setSelected(true);
    cbmi.addItemListener(new ItemListener() {
      public void itemStateChanged(ItemEvent e) {
        JCheckBoxMenuItem mi = (JCheckBoxMenuItem) (e.getSource());
        boolean selected = (e.getStateChange() == ItemEvent.SELECTED);
        leftAction.setEnabled(selected);
      }
    });
    ableMenu.add(cbmi);
    cbmi = new JCheckBoxMenuItem("Second action enabled");
    cbmi.setSelected(true);
    cbmi.addItemListener(new ItemListener() {
      public void itemStateChanged(ItemEvent e) {
        JCheckBoxMenuItem mi = (JCheckBoxMenuItem) (e.getSource());
        boolean selected = (e.getStateChange() == ItemEvent.SELECTED);
        middleAction.setEnabled(selected);
      }
    });
    ableMenu.add(cbmi);
    cbmi = new JCheckBoxMenuItem("Third action enabled");
    cbmi.setSelected(true);
    cbmi.addItemListener(new ItemListener() {
      public void itemStateChanged(ItemEvent e) {
        JCheckBoxMenuItem mi = (JCheckBoxMenuItem) (e.getSource());
        boolean selected = (e.getStateChange() == ItemEvent.SELECTED);
        rightAction.setEnabled(selected);
      }
    });
    ableMenu.add(cbmi);
    return ableMenu;
  }
  protected void displayResult(String actionDescription, ActionEvent e) {
    String s = ("Action event detected by: " + actionDescription + newline
        + "    Event source: " + e.getSource() + newline);
    textArea.append(s);
  }
  public static void main(String[] args) {
    ActionDemo frame = new ActionDemo();
    frame.pack();
    frame.setVisible(true);
  }
}

Action events are fired by subclasses of AbstractButton and includes buttons, checkboxes, and menus.

 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.AbstractButton;
import javax.swing.JButton;
import javax.swing.JFrame;
public class Main {
  public static void main(String[] argv) throws Exception {
    AbstractButton button = new JButton("OK");
    button.addActionListener(new MyActionListener());
    JFrame f = new JFrame();
    f.add(button);
    f.setSize(300, 300);
    f.setVisible(true);
  }
}
class MyActionListener implements ActionListener {
  public void actionPerformed(ActionEvent evt) {
    AbstractButton button = (AbstractButton) evt.getSource();
    System.out.println(button.getName());
  }
}

Apply special filter to a JTextField

  
import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.PlainDocument;
class JTextFieldFilter extends PlainDocument {
  public static final String NUMERIC = "0123456789";
  protected String acceptedChars = null;
  protected boolean negativeAccepted = false;
  public JTextFieldFilter() {
    this(NUMERIC);
  }
  public JTextFieldFilter(String acceptedchars) {
    acceptedChars = acceptedchars;
  }
  public void setNegativeAccepted(boolean negativeaccepted) {
    if (acceptedChars.equals(NUMERIC)) {
      negativeAccepted = negativeaccepted;
      acceptedChars += "-";
    }
  }
  public void insertString(int offset, String str, AttributeSet attr) throws BadLocationException {
    if (str == null)
      return;
    for (int i = 0; i < str.length(); i++) {
      if (acceptedChars.indexOf(str.valueOf(str.charAt(i))) == -1)
        return;
    }
    if (negativeAccepted && str.indexOf("-") != -1) {
      if (str.indexOf("-") != 0 || offset != 0) {
        return;
      }
    }
    super.insertString(offset, str, attr);
  }
}
public class Main extends JFrame{
  public static void main(String[] argv) throws Exception {
    new Main();
  }
  public Main() {
    JTextField tf1, tf1b, tf1c, tf2, tf3;
    JLabel l1, l1b, l1c, l2, l3;
    setLayout(new FlowLayout());
    //
    l1 = new JLabel("only numerics");
    tf1 = new JTextField(10);
    getContentPane().add(l1);
    getContentPane().add(tf1);
    tf1.setDocument(new JTextFieldFilter(JTextFieldFilter.NUMERIC));
    setSize(300,300);
    setVisible(true);
  }
}

A text component has an action map with actions and keymaps with actions

  

import javax.swing.Action;
import javax.swing.JTextField;
import javax.swing.text.JTextComponent;
import javax.swing.text.Keymap;
public class Main {
  public static void main(String[] argv) throws Exception {
    JTextComponent component = new JTextField();
    if (component instanceof JTextComponent) {
      JTextComponent textComp = (JTextComponent) component;
      Keymap keymap = textComp.getKeymap();
      while (keymap != null) {
        Action[] actions = keymap.getBoundActions();
        for (int i = 0; i < actions.length; i++) {
          Action action = actions[i];
        }
        Action defaultAction = keymap.getDefaultAction();
        keymap = keymap.getResolveParent();
      }
    }
  }
}

Creating an Action

  
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.KeyStroke;
public class Main {
  public static void main(String[] argv) throws Exception {
    final Action action = new AbstractAction("Action Name") {
      {
        putValue(Action.SHORT_DESCRIPTION, "Tool Tip Text");
        putValue(Action.LONG_DESCRIPTION, "Help Text");
        Icon icon = new ImageIcon("icon.gif");
        putValue(Action.SMALL_ICON, icon);
        putValue(Action.MNEMONIC_KEY, new Integer(java.awt.event.KeyEvent.VK_A));
        putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke("control F2"));
      }
      public void actionPerformed(ActionEvent evt) {
        System.out.println("action");
      }
    };
    JButton button = new JButton(action);
  }
}

Enabling an Action

  
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
public class Main {
  public static void main(String[] argv) throws Exception {
    final Action action = new AbstractAction("Action Name") {
      public void actionPerformed(ActionEvent evt) {
        System.out.println("action");
      }
    };
   
    JFrame frame = new JFrame();
    JButton button = new JButton(action);
    JTextField textfield = new JTextField();
    textfield.getInputMap(JComponent.WHEN_FOCUSED).put(KeyStroke.getKeyStroke("F2"),
        action.getValue(Action.NAME));
    textfield.getActionMap().put(action.getValue(Action.NAME), action);
  }
}

Listing the Actions in a Component

  
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.JButton;
public class Main {
  public static void main(String[] argv) throws Exception {
    JButton component = new JButton("button");
    ActionMap map = component.getActionMap();
    list(map, map.keys());
    list(map, map.allKeys());
  }
  static void list(ActionMap map, Object[] actionKeys) {
    if (actionKeys == null) {
      return;
    }
    for (int i = 0; i < actionKeys.length; i++) {
      // Get the action bound to this action key
      while (map.get(actionKeys[i]) == null) {
        map = map.getParent();
      }
      Action action = (Action) map.get(actionKeys[i]);
    }
  }
}

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) + ")";
  }
}

Sharing an InputMap or an ActionMap Between Two Components

  
import java.awt.event.ActionEvent;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;
import javax.swing.text.JTextComponent;
public class Main {
  public static void main(String[] argv) {
    InputMap im = new JTextArea().getInputMap(JComponent.WHEN_FOCUSED);
    im.put(KeyStroke.getKeyStroke("F2"), "actionName");
    ActionMap am = new JTextArea().getActionMap();
    am.put("actionName", new AbstractAction("actionName") {
      public void actionPerformed(ActionEvent evt) {
        System.out.println((JTextComponent) evt.getSource());
      }
    });
    im.put(KeyStroke.getKeyStroke("F3"), "actionName2");
    am.put("actionName2", new AbstractAction("actionName2") {
      public void actionPerformed(ActionEvent evt) {
        System.out.println((JTextComponent) evt.getSource());
      }
    });
    JButton component1 = new JButton("button 1");
    JButton component2 = new JButton("button 2");
    component1.setInputMap(JComponent.WHEN_FOCUSED, im);
    component2.setInputMap(JComponent.WHEN_FOCUSED, im);
    component1.setActionMap(am);
    component2.setActionMap(am);

  }
}