keyevent.java

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

        case VK_CIRCUMFLEX:
            return Toolkit.getProperty("AWT.circumflex", "Circumflex");

        case VK_DOLLAR:
            return Toolkit.getProperty("AWT.dollar", "Dollar");

        case VK_EURO_SIGN:
            return Toolkit.getProperty("AWT.euro", "Euro");

        case VK_EXCLAMATION_MARK:
            return Toolkit.getProperty("AWT.exclamationMark", "Exclamation Mark");

        case VK_INVERTED_EXCLAMATION_MARK:
            return Toolkit.getProperty("AWT.invertedExclamationMark", "Inverted Exclamation Mark");

        case VK_LEFT_PARENTHESIS:
            return Toolkit.getProperty("AWT.leftParenthesis", "Left Parenthesis");

        case VK_NUMBER_SIGN:
            return Toolkit.getProperty("AWT.numberSign", "Number Sign");

        case VK_MINUS:
            return Toolkit.getProperty("AWT.minus", "Minus");

        case VK_PLUS:
            return Toolkit.getProperty("AWT.plus", "Plus");

        case VK_RIGHT_PARENTHESIS:
            return Toolkit.getProperty("AWT.rightParenthesis", "Right Parenthesis");

        case VK_UNDERSCORE:
            return Toolkit.getProperty("AWT.underscore", "Underscore");

        case VK_FINAL:
            return Toolkit.getProperty("AWT.final", "Final");

        case VK_CONVERT:
            return Toolkit.getProperty("AWT.convert", "Convert");

        case VK_NONCONVERT:
            return Toolkit.getProperty("AWT.noconvert", "No Convert");

        case VK_ACCEPT:
            return Toolkit.getProperty("AWT.accept", "Accept");

        case VK_MODECHANGE:
            return Toolkit.getProperty("AWT.modechange", "Mode Change");

        case VK_KANA:
            return Toolkit.getProperty("AWT.kana", "Kana");

        case VK_KANJI:
            return Toolkit.getProperty("AWT.kanji", "Kanji");

        case VK_ALPHANUMERIC:
            return Toolkit.getProperty("AWT.alphanumeric", "Alphanumeric");

        case VK_KATAKANA:
            return Toolkit.getProperty("AWT.katakana", "Katakana");

        case VK_HIRAGANA:
            return Toolkit.getProperty("AWT.hiragana", "Hiragana");

        case VK_FULL_WIDTH:
            return Toolkit.getProperty("AWT.fullWidth", "Full-Width");

        case VK_HALF_WIDTH:
            return Toolkit.getProperty("AWT.halfWidth", "Half-Width");

        case VK_ROMAN_CHARACTERS:
            return Toolkit.getProperty("AWT.romanCharacters", "Roman Characters");

        case VK_ALL_CANDIDATES:
            return Toolkit.getProperty("AWT.allCandidates", "All Candidates");

        case VK_PREVIOUS_CANDIDATE:
            return Toolkit.getProperty("AWT.previousCandidate", "Previous Candidate");

        case VK_CODE_INPUT:
            return Toolkit.getProperty("AWT.codeInput", "Code Input");

        case VK_JAPANESE_KATAKANA:
            return Toolkit.getProperty("AWT.japaneseKatakana", "Japanese Katakana");

        case VK_JAPANESE_HIRAGANA:
            return Toolkit.getProperty("AWT.japaneseHiragana", "Japanese Hiragana");

        case VK_JAPANESE_ROMAN:
            return Toolkit.getProperty("AWT.japaneseRoman", "Japanese Roman");

        case VK_KANA_LOCK:
            return Toolkit.getProperty("AWT.kanaLock", "Kana Lock");

        case VK_INPUT_METHOD_ON_OFF:
            return Toolkit.getProperty("AWT.inputMethodOnOff", "Input Method On/Off");

        case VK_AGAIN:
            return Toolkit.getProperty("AWT.again", "Again");

        case VK_UNDO:
            return Toolkit.getProperty("AWT.undo", "Undo");

        case VK_COPY:
            return Toolkit.getProperty("AWT.copy", "Copy");

        case VK_PASTE:
            return Toolkit.getProperty("AWT.paste", "Paste");

        case VK_CUT:
            return Toolkit.getProperty("AWT.cut", "Cut");

        case VK_FIND:
            return Toolkit.getProperty("AWT.find", "Find");

        case VK_PROPS:
            return Toolkit.getProperty("AWT.props", "Props");

        case VK_STOP:
            return Toolkit.getProperty("AWT.stop", "Stop");

        case VK_COMPOSE:
            return Toolkit.getProperty("AWT.compose", "Compose");

        case VK_ALT_GRAPH:
            return Toolkit.getProperty("AWT.altGraph", "Alt Graph");
        }
        if (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) {
            String numpad = Toolkit.getProperty("AWT.numpad", "NumPad");
            char c = (char) (keyCode - VK_NUMPAD0 + '0');
            return numpad + "-" + c;
        }
        String unknown = Toolkit.getProperty("AWT.unknown", "Unknown keyCode");
        return unknown + ": 0x" + Integer.toString(keyCode, 16);
    }

    /**
     * Returns a String describing the modifier key(s), such as "Shift",
     * or "Ctrl+Shift".  These strings can be localized by changing the
     * awt.properties file.
     *
     * @return string a text description of the combination of modifier
     *                keys that were held down during the event
     */
    public static String getKeyModifiersText(int modifiers) {
        StringBuffer buf = new StringBuffer();
        if ((modifiers & InputEvent.META_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.meta", "Meta"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.CTRL_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.control", "Ctrl"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.ALT_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.alt", "Alt"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.SHIFT_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.shift", "Shift"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.ALT_GRAPH_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.altGraph", "Alt Graph"));
            buf.append("+");
        }
        if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {
            buf.append(Toolkit.getProperty("AWT.button1", "Button1"));
            buf.append("+");
        }
        if (buf.length() > 0) {
            buf.setLength(buf.length() - 1); // remove trailing '+'
        }
        return buf.toString();
    }

    /**
     * Returns whether the key in this event is an "action" key.
     * Typically an action key does not fire a unicode character and is
     * not a modifier key.
     *
     * @return <code>true</code> if the key is an "action" key,
     *         <code>false</code> otherwise
     */
    public boolean isActionKey() {
        switch (keyCode) {
        case VK_HOME:
        case VK_END:
        case VK_PAGE_UP:
        case VK_PAGE_DOWN:
        case VK_UP:
        case VK_DOWN:
        case VK_LEFT:
        case VK_RIGHT:
        case VK_KP_LEFT:
        case VK_KP_UP:
        case VK_KP_RIGHT:
        case VK_KP_DOWN:
        case VK_F1:
        case VK_F2:
        case VK_F3:
        case VK_F4:
        case VK_F5:
        case VK_F6:
        case VK_F7:
        case VK_F8:
        case VK_F9:
        case VK_F10:
        case VK_F11:
        case VK_F12:
        case VK_F13:
        case VK_F14:
        case VK_F15:
        case VK_F16:
        case VK_F17:
        case VK_F18:
        case VK_F19:
        case VK_F20:
        case VK_F21:
        case VK_F22:
        case VK_F23:
        case VK_F24:
        case VK_PRINTSCREEN:
        case VK_SCROLL_LOCK:
        case VK_CAPS_LOCK:
        case VK_NUM_LOCK:
        case VK_PAUSE:
        case VK_INSERT:
        case VK_FINAL:
        case VK_CONVERT:
        case VK_NONCONVERT:
        case VK_ACCEPT:
        case VK_MODECHANGE:
        case VK_KANA:
        case VK_KANJI:
        case VK_ALPHANUMERIC:
        case VK_KATAKANA:
        case VK_HIRAGANA:
        case VK_FULL_WIDTH:
        case VK_HALF_WIDTH:
        case VK_ROMAN_CHARACTERS:
        case VK_ALL_CANDIDATES:
        case VK_PREVIOUS_CANDIDATE:
        case VK_CODE_INPUT:
        case VK_JAPANESE_KATAKANA:
        case VK_JAPANESE_HIRAGANA:
        case VK_JAPANESE_ROMAN:
        case VK_KANA_LOCK:
        case VK_INPUT_METHOD_ON_OFF:
        case VK_AGAIN:
        case VK_UNDO:
        case VK_COPY:
        case VK_PASTE:
        case VK_CUT:
        case VK_FIND:
        case VK_PROPS:
        case VK_STOP:
        case VK_HELP:
            return true;
        }
        return false;
    }

    /**
     * Returns a parameter string identifying this event.
     * This method is useful for event logging and for debugging.
     *
     * @return a string identifying the event and its attributes
     */
    public String paramString() {
        String typeStr;
        switch (id) {
        case KEY_PRESSED:
            typeStr = "KEY_PRESSED";
            break;

        case KEY_RELEASED:
            typeStr = "KEY_RELEASED";
            break;

        case KEY_TYPED:
            typeStr = "KEY_TYPED";
            break;

        default:
            typeStr = "unknown type";
        }
        String str = typeStr + ",keyCode=" + keyCode;
        if (isActionKey() || keyCode == VK_ENTER || keyCode == VK_BACK_SPACE ||
            keyCode == VK_TAB || keyCode == VK_ESCAPE || keyCode == VK_DELETE ||
            (keyCode >= VK_NUMPAD0 && keyCode <= VK_NUMPAD9) ||
            keyCode == VK_COMPOSE || keyCode == VK_ALT_GRAPH) {
            str += "," + getKeyText(keyCode);
        } else if (keyChar == '\n' || keyChar == '\b' ||
            keyChar == '\t' || keyChar == VK_ESCAPE || keyChar == VK_DELETE) {
            str += "," + getKeyText(keyChar);
        } else {
            str += ",keyChar='" + keyChar + "'";
        }
        if (getModifiers() != 0) {
            str += ",modifiers=" + getKeyModifiersText(modifiers);
        }
                if (getModifiersEx() != 0) {
         str += ",extModifiers=" + getModifiersExText(modifiers);
         }

/*
         String locationStr;
         switch (keyLocation) {
         case KEY_LOCATION_UNKNOWN:
         locationStr = "KEY_LOCATION_UNKNOWN";
         break;
         case KEY_LOCATION_STANDARD:
         locationStr = "KEY_LOCATION_STANDARD";
         break;
         case KEY_LOCATION_LEFT:
         locationStr = "KEY_LOCATION_LEFT";
         break;
         case KEY_LOCATION_RIGHT:
         locationStr = "KEY_LOCATION_RIGHT";
         break;
         case KEY_LOCATION_NUMPAD:
         locationStr = "KEY_LOCATION_NUMPAD";
         break;
         default:
         locationStr = "KEY_LOCATION_UNKNOWN";
         break;
         }
         str += ",keyLocation=" + locationStr;
         */
        return str;
    }

    /**
     * Sets new modifiers by the old ones. The key modifiers
     * override overlaping mouse modifiers.
     */

    private void setNewModifiers() {
       if ((modifiers & SHIFT_MASK) != 0) {
          modifiers |= SHIFT_DOWN_MASK;
       }
       if ((modifiers & ALT_MASK) != 0) {
          modifiers |= ALT_DOWN_MASK;
       }
       if ((modifiers & CTRL_MASK) != 0) {
          modifiers |= CTRL_DOWN_MASK;
       }
       if ((modifiers & META_MASK) != 0) {
          modifiers |= META_DOWN_MASK;
       }
       if ((modifiers & ALT_GRAPH_MASK) != 0) {
          modifiers |= ALT_GRAPH_DOWN_MASK;
       }
       if ((modifiers & BUTTON1_MASK) != 0) {
          modifiers |= BUTTON1_DOWN_MASK;
       }
    }

    /**
     * Sets old modifiers by the new ones.
     */

    private void setOldModifiers() {
       if ((modifiers & SHIFT_DOWN_MASK) != 0) {
          modifiers |= SHIFT_MASK;
       }
       if ((modifiers & ALT_DOWN_MASK) != 0) {
          modifiers |= ALT_MASK;
       }
       if ((modifiers & CTRL_DOWN_MASK) != 0) {
          modifiers |= CTRL_MASK;
       }
       if ((modifiers & META_DOWN_MASK) != 0) {
          modifiers |= META_MASK;
       }
       if ((modifiers & ALT_GRAPH_DOWN_MASK) != 0) {
          modifiers |= ALT_GRAPH_MASK;
       }
       if ((modifiers & BUTTON1_DOWN_MASK) != 0) {
          modifiers |= BUTTON1_MASK;
       }
    }

    /**
     * Serialization method.
     * @serial
     */
    private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        if (getModifiers() != 0 && getModifiersEx() == 0) {
           setNewModifiers();
        }
    }
    
    /**
     * Set the source of this KeyEvent. Dispatching this event subsequent
     * to this operation will send this event to the new Object.
     *
     * @param newSource the KeyEvent's new source.
     */
    public void setSource(Object newSource) {
        source = newSource;
    }    
}