下面列出了java.awt.event.KeyEvent#CHAR_UNDEFINED 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
boolean process() {
if (isPureModifierEvent(KeyEvent.KEY_PRESSED)) {
myContext.actionKey = myContext.keyToProcess;
return true;
}
if (myContext.keyToProcess.getID() == KeyEvent.KEY_RELEASED && myContext.keyToProcess.getKeyChar() == KeyEvent.CHAR_UNDEFINED) {
final int pressedModifiers = myContext.keyToProcess.getKeyCode() & myContext.actionKey.getModifiersEx();
if (pressedModifiers == 0) {
myProcessor.setState(myProcessor.myFinish);
return myProcessor.myState.process();
}
}
if (myContext.keyToProcess.getID() == KeyEvent.KEY_PRESSED) {
myContext.actionKey = myContext.keyToProcess;
myProcessor.setState(myProcessor.myWaitForActionEnd);
return true;
}
return false;
}
public int test(String [] args) {
boolean ret = false;
myAWTKeyStroke s = new myAWTKeyStroke();
System.out.println(
"s.getKeyChar() = " + (int) s.getKeyChar() + " (65535 expected).");
System.out.println("s.getKeyChar() == KeyEvent.CHAR_UNDEFINED: "
+ (s.getKeyChar() == KeyEvent.CHAR_UNDEFINED));
System.out.println("s.getKeyCode() == KeyEvent.VK_UNDEFINED: "
+ (s.getKeyCode() == KeyEvent.VK_UNDEFINED));
System.out.println(
"s.getModifiers() = " + s.getModifiers() + " (0 expected)");
System.out.println(
"s.isOnKeyRelease() = " + s.isOnKeyRelease() + " (false expected)");
return ((int) s.getKeyChar() == 65535)
&& (s.getKeyChar() == KeyEvent.CHAR_UNDEFINED)
&& (s.getKeyCode() == KeyEvent.VK_UNDEFINED)
&& (s.getModifiers() == 0)
&& (!s.isOnKeyRelease())
? (0) : (1);
}
private int getMnemonicCharIndex(ActionButton button, AnAction action, String text) {
final int mnemonicIndex = button.getPresentation().getDisplayedMnemonicIndex();
if (mnemonicIndex != -1) {
return mnemonicIndex;
}
final ShortcutSet shortcutSet = action.getShortcutSet();
final Shortcut[] shortcuts = shortcutSet.getShortcuts();
for (int i = 0; i < shortcuts.length; i++) {
Shortcut shortcut = shortcuts[i];
if (shortcut instanceof KeyboardShortcut) {
KeyboardShortcut keyboardShortcut = (KeyboardShortcut)shortcut;
if (keyboardShortcut.getSecondKeyStroke() == null) { // we are interested only in "mnemonic-like" shortcuts
final KeyStroke keyStroke = keyboardShortcut.getFirstKeyStroke();
final int modifiers = keyStroke.getModifiers();
if ((modifiers & KeyEvent.ALT_MASK) != 0) {
return (keyStroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED)
? text.indexOf(keyStroke.getKeyChar())
: text.indexOf(KeyEvent.getKeyText(keyStroke.getKeyCode()));
}
}
}
}
return -1;
}
protected Expression instantiate(Object oldInstance, Encoder out) {
AWTKeyStroke key = (AWTKeyStroke) oldInstance;
char ch = key.getKeyChar();
int code = key.getKeyCode();
int mask = key.getModifiers();
boolean onKeyRelease = key.isOnKeyRelease();
Object[] args = null;
if (ch == KeyEvent.CHAR_UNDEFINED) {
args = !onKeyRelease
? new Object[]{code, mask}
: new Object[]{code, mask, onKeyRelease};
} else if (code == KeyEvent.VK_UNDEFINED) {
if (!onKeyRelease) {
args = (mask == 0)
? new Object[]{ch}
: new Object[]{ch, mask};
} else if (mask == 0) {
args = new Object[]{ch, onKeyRelease};
}
}
if (args == null) {
throw new IllegalStateException("Unsupported KeyStroke: " + key);
}
Class type = key.getClass();
String name = type.getName();
// get short name of the class
int index = name.lastIndexOf('.') + 1;
if (index > 0) {
name = name.substring(index);
}
return new Expression( key, type, "get" + name, args );
}
protected void keyEvent(KeyEvent e) {
Number delay = (Number) UIManager.get("textSelectionDelay");
if (delay == null)
delay = Integer.valueOf(500);
if (e.getWhen() - lastKeyEvent > delay.intValue()) {
typedText.delete(0, typedText.length());
}
String origTypedText = typedText.toString();
if (e.getKeyCode() == KeyEvent.VK_BACK_SPACE
|| e.getKeyCode() == KeyEvent.VK_DELETE) {
if (typedText.length() != 0) {
typedText.substring(0, typedText.length() - 1);
}
} else {
char ch = e.getKeyChar();
if (ch != KeyEvent.CHAR_UNDEFINED) {
typedText.append(ch);
}
}
if (!origTypedText.equals(typedText.toString())) {
lastKeyEvent = e.getWhen();
boolean success = changeSelectionUsingText(e, typedText.toString());
if (success)
e.consume();
}
}
protected Expression instantiate(Object oldInstance, Encoder out) {
AWTKeyStroke key = (AWTKeyStroke) oldInstance;
char ch = key.getKeyChar();
int code = key.getKeyCode();
int mask = key.getModifiers();
boolean onKeyRelease = key.isOnKeyRelease();
Object[] args = null;
if (ch == KeyEvent.CHAR_UNDEFINED) {
args = !onKeyRelease
? new Object[]{code, mask}
: new Object[]{code, mask, onKeyRelease};
} else if (code == KeyEvent.VK_UNDEFINED) {
if (!onKeyRelease) {
args = (mask == 0)
? new Object[]{ch}
: new Object[]{ch, mask};
} else if (mask == 0) {
args = new Object[]{ch, onKeyRelease};
}
}
if (args == null) {
throw new IllegalStateException("Unsupported KeyStroke: " + key);
}
Class<?> type = key.getClass();
String name = type.getName();
// get short name of the class
int index = name.lastIndexOf('.') + 1;
if (index > 0) {
name = name.substring(index);
}
return new Expression( key, type, "get" + name, args );
}
private boolean isStartEditingEvent(KeyEvent e, boolean includeCharTyping) {
boolean result = e.getKeyCode() == KeyEvent.VK_F2
|| e.getKeyCode() == KeyEvent.VK_INSERT
|| (myNewRowAction != null && KeyStroke.getKeyStrokeForEvent(e).equals(myNewRowAction.getKeyStroke()));
if (!result && includeCharTyping) {
result = e.getKeyChar() != KeyEvent.CHAR_UNDEFINED && !e.isMetaDown() && !e.isControlDown();
}
return result;
}
protected Expression instantiate(Object oldInstance, Encoder out) {
AWTKeyStroke key = (AWTKeyStroke) oldInstance;
char ch = key.getKeyChar();
int code = key.getKeyCode();
int mask = key.getModifiers();
boolean onKeyRelease = key.isOnKeyRelease();
Object[] args = null;
if (ch == KeyEvent.CHAR_UNDEFINED) {
args = !onKeyRelease
? new Object[]{code, mask}
: new Object[]{code, mask, onKeyRelease};
} else if (code == KeyEvent.VK_UNDEFINED) {
if (!onKeyRelease) {
args = (mask == 0)
? new Object[]{ch}
: new Object[]{ch, mask};
} else if (mask == 0) {
args = new Object[]{ch, onKeyRelease};
}
}
if (args == null) {
throw new IllegalStateException("Unsupported KeyStroke: " + key);
}
Class<?> type = key.getClass();
String name = type.getName();
// get short name of the class
int index = name.lastIndexOf('.') + 1;
if (index > 0) {
name = name.substring(index);
}
return new Expression( key, type, "get" + name, args );
}
public void testDeleteRowActionByBackSpace() {
KeyEvent keyEvent = new KeyEvent(fileEditor.getTable(), KeyEvent.KEY_RELEASED, JComponent.WHEN_FOCUSED,
KeyEvent.CTRL_DOWN_MASK, KeyEvent.VK_BACK_SPACE, KeyEvent.CHAR_UNDEFINED);
fileEditor.tableEditorKeyListener.keyReleased(keyEvent);
assertTrue(fileEditor.getDataHandler().equalsCurrentState(initialState));
fileEditor.getTable().setRowSelectionInterval(1, 1);
fileEditor.getTable().setColumnSelectionInterval(1, 1);
fileEditor.tableEditorKeyListener.keyReleased(keyEvent);
Object[][] newState = fileEditor.getDataHandler().getCurrentState();
assertEquals(3, newState.length);
assertEquals("just another line with leading and trailing whitespaces", newState[1][0]);
assertEquals(" and one more value ", newState[1][1]);
}
public void testNotClearCellActionByDeleteWhenEditing() {
KeyEvent enterKeyEvent = new KeyEvent(fileEditor.getTable(), KeyEvent.KEY_RELEASED, JComponent.WHEN_FOCUSED,
0, KeyEvent.VK_ENTER, KeyEvent.CHAR_UNDEFINED);
KeyEvent deleteKeyEvent = new KeyEvent(fileEditor.getTable(), KeyEvent.KEY_RELEASED, JComponent.WHEN_FOCUSED,
0, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED);
fileEditor.getTable().setRowSelectionInterval(1, 1);
fileEditor.getTable().setColumnSelectionInterval(1, 1);
fileEditor.tableEditorKeyListener.keyReleased(enterKeyEvent);
fileEditor.tableEditorKeyListener.keyReleased(deleteKeyEvent);
Object[][] newState = fileEditor.getDataHandler().getCurrentState();
assertEquals("this is column header 2", newState[1][1]);
}
public void setLabel(String label, char keyChar, int keyCode, int modifiers) {
int keyMask = modifiers;
if (keyCode == KeyEvent.VK_UNDEFINED) {
MenuShortcut shortcut = ((MenuItem)getTarget()).getShortcut();
if (shortcut != null) {
keyCode = shortcut.getKey();
keyMask |= InputEvent.META_MASK;
if (shortcut.usesShiftModifier()) {
keyMask |= InputEvent.SHIFT_MASK;
}
}
}
if (label == null) {
label = "";
}
// <rdar://problem/3654824>
// Native code uses a keyChar of 0 to indicate that the
// keyCode should be used to generate the shortcut. Translate
// CHAR_UNDEFINED into 0.
if (keyChar == KeyEvent.CHAR_UNDEFINED) {
keyChar = 0;
}
final String finalLabel = label;
final char finalKeyChar = keyChar;
final int finalKeyCode = keyCode;
final int finalKeyMask = keyMask;
execute(ptr -> nativeSetLabel(ptr, finalLabel, finalKeyChar,
finalKeyCode, finalKeyMask));
}
public void testDeleteRowActionByDelete() {
KeyEvent keyEvent = new KeyEvent(fileEditor.getTable(), KeyEvent.KEY_RELEASED, JComponent.WHEN_FOCUSED,
KeyEvent.CTRL_DOWN_MASK, KeyEvent.VK_DELETE, KeyEvent.CHAR_UNDEFINED);
fileEditor.tableEditorKeyListener.keyReleased(keyEvent);
assertTrue(fileEditor.getDataHandler().equalsCurrentState(initialState));
fileEditor.getTable().setRowSelectionInterval(1, 1);
fileEditor.getTable().setColumnSelectionInterval(1, 1);
fileEditor.tableEditorKeyListener.keyReleased(keyEvent);
Object[][] newState = fileEditor.getDataHandler().getCurrentState();
assertEquals(3, newState.length);
assertEquals("just another line with leading and trailing whitespaces", newState[1][0]);
assertEquals(" and one more value ", newState[1][1]);
}
@Override
public void keyPressed(KeyEvent event) {
msg1 = "";
System.out.println("keyPressed CODE1 "+event.getKeyCode());
int myCode = event.getKeyCode();
System.out.println("keyPressed CODE2 "+myCode);
System.out.println("keyPressed CHAR3 "+event.getKeyChar());
System.out.println("keyPressed CHAR4 "+KeyEvent.getKeyText(event.getKeyCode()));
System.out.println("keyPressed CHAR5 "+KeyEvent.getKeyText(myCode));
System.out.println("keyPressed isActionKey "+event.isActionKey());
System.out.println("keyPressed isAltDown "+event.isAltDown());
System.out.println("keyPressed isAltGraphDown "+event.isAltGraphDown());
System.out.println("keyPressed isConsumed "+event.isConsumed());
System.out.println("keyPressed isControlDown "+event.isControlDown());
System.out.println("keyPressed isMetaDown "+event.isMetaDown());
System.out.println("keyPressed isShiftDown "+event.isShiftDown());
System.out.println("keyPressed paramString "+event.paramString());
if (event.getKeyChar() == KeyEvent.CHAR_UNDEFINED) {
int key = event.getKeyCode();
// Funktionstaste abfragen
if (key == KeyEvent.VK_F1) {
msg1 = "F1";
} else if (key == KeyEvent.VK_F2) {
msg1 = "F2";
} else if (key == KeyEvent.VK_F3) {
msg1 = "F3";
}
// Modifier abfragen
if (msg1.length() > 0) {
if (event.isAltDown()) {
msg1 = "ALT + " + msg1;
}
if (event.isControlDown()) {
msg1 = "STRG + " + msg1;
}
if (event.isShiftDown()) {
msg1 = "UMSCHALT + " + msg1;
}
}
}
repaint();
}
@Override
public void keyPressed(final KeyEvent event) {
if (!isActive()) {
return;
}
if (event.getKeyCode() == KeyEvent.VK_ESCAPE) {
deactivateLabelContent();
return;
}
if ((event.getKeyCode() == KeyEvent.VK_TAB) && (event.getModifiers() != 0)
&& (event.getModifiers() != InputEvent.SHIFT_DOWN_MASK)) {
return;
}
if (!getActiveLabelContent().isSelectable()) {
return;
}
CAbstractKeyBehavior behaviour = null;
final char keyText = KeyEvent.getKeyText(event.getKeyCode()).charAt(0);
if (event.isControlDown() && (keyText >= 'A') && (keyText <= 'Z')) {
behaviour = m_ctrlKeyBehaviourMap.get(event.getKeyCode());
}
if (behaviour == null) {
behaviour = m_keyBehaviourMap.get(event.getKeyCode());
if ((behaviour == null) && (event.getKeyChar() != KeyEvent.CHAR_UNDEFINED)
&& !event.isControlDown() && getActiveLabelContent().isEditable()) {
behaviour = m_keyBehaviourMap.get(null);
}
}
if (behaviour != null) {
int y = -1;
String oldContent = "";
if (getActiveLabelContent().isEditable()) {
y = getActiveLabelContent().getCaret().getYmouseReleased();
oldContent = getContentSnippet(y);
}
behaviour.keyPressed(getActiveLabelContent(), event);
if (y > -1) {
final String newContent = getContentSnippet(y);
if (!oldContent.equals(newContent) && !oldContent.isEmpty()) {
for (final ILabelEditableContentListener listener : m_editModeListener) {
listener.editableContentChanged(getActiveLabelContent());
}
}
}
m_activeRealizer.regenerate();
m_activeRealizer.repaint();
m_graph.updateViews();
}
event.consume();
}
@Override
public boolean editCellAt(final int row, final int column, final EventObject e) {
if (cellEditor != null && !cellEditor.stopCellEditing()) {
return false;
}
if (row < 0 || row >= getRowCount() || column < 0 || column >= getColumnCount()) {
return false;
}
if (!isCellEditable(row, column)) {
return false;
}
if (e instanceof KeyEvent) {
// do not start editing in autoStartsEdit mode on Ctrl-Z and other non-typed events
if (!UIUtil.isReallyTypedEvent((KeyEvent)e) || ((KeyEvent)e).getKeyChar() == KeyEvent.CHAR_UNDEFINED) return false;
SpeedSearchSupply supply = SpeedSearchSupply.getSupply(this);
if (supply != null && supply.isPopupActive()) {
return false;
}
}
final TableCellEditor editor = getCellEditor(row, column);
if (editor != null && editor.isCellEditable(e)) {
editorComp = prepareEditor(editor, row, column);
//((JComponent)editorComp).setBorder(null);
if (editorComp == null) {
removeEditor();
return false;
}
editorComp.setBounds(getCellRect(row, column, false));
add(editorComp);
editorComp.validate();
if (surrendersFocusOnKeyStroke()) {
// this replaces focus request in JTable.processKeyBinding
final IdeFocusManager focusManager = IdeFocusManager.findInstanceByComponent(this);
focusManager.setTypeaheadEnabled(false);
focusManager.requestFocus(editorComp, true).doWhenProcessed(() -> focusManager.setTypeaheadEnabled(true));
}
setCellEditor(editor);
setEditingRow(row);
setEditingColumn(column);
editor.addCellEditorListener(this);
return true;
}
return false;
}
/**
* Handle a key typed event. This inserts the key into the text area.
*/
@Override
@SuppressWarnings("unchecked")
public void keyTyped(KeyEvent evt) {
int modifiers = evt.getModifiers();
char c = evt.getKeyChar();
if (c != KeyEvent.CHAR_UNDEFINED && (modifiers & InputEvent.ALT_MASK) == 0) {
if (c >= 0x20 && c != 0x7f) {
KeyStroke keyStroke = KeyStroke.getKeyStroke(Character.toUpperCase(c));
Object o = currentBindings.get(keyStroke);
if (o instanceof Hashtable) {
currentBindings = (Hashtable<KeyStroke, Object>) o;
return;
} else if (o instanceof ActionListener) {
currentBindings = bindings;
executeAction((ActionListener) o, evt.getSource(), String.valueOf(c));
return;
}
currentBindings = bindings;
if (grabAction != null) {
handleGrabAction(evt);
return;
}
// 0-9 adds another 'digit' to the repeat number
if (repeat && Character.isDigit(c)) {
repeatCount *= 10;
repeatCount += (c - '0');
return;
}
executeAction(INSERT_CHAR, evt.getSource(), String.valueOf(evt.getKeyChar()));
repeatCount = 0;
repeat = false;
}
}
}
public static AWTKeyStroke getAWTKeyStroke(final int keyCode, final int modifiers,
final boolean onKeyRelease) {
return (AWTKeyStroke) (Object) new TAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, onKeyRelease);
}
public static AWTKeyStroke getAWTKeyStroke(final int keyCode, final int modifiers) {
return (AWTKeyStroke) (Object) new TAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, false);
}
public Action getAction(final KeyStroke key) {
switch (key.getKeyCode()) {
case KeyEvent.VK_SHIFT:
case KeyEvent.VK_CONTROL:
case KeyEvent.VK_ALT:
case KeyEvent.VK_ALT_GRAPH:
case KeyEvent.VK_META:
case KeyEvent.VK_UNDEFINED:
case KeyEvent.CHAR_UNDEFINED:
// Not actually a bindable key press.
return null;
}
if (key.isOnKeyRelease()) {
// Again, not really our business here.
return null;
}
LOG.log(Level.FINE, "getAction {0}", key);
Map<KeyStroke,Binding> binder = bindings();
for (KeyStroke ctx : context) {
Binding sub = binder.get(ctx);
if (sub == null) {
resetContext();
return BROKEN; // no entry found after known prefix
}
binder = sub.nested;
if (binder == null) {
resetContext();
return BROKEN; // anomalous, expected to find submap here
}
}
Binding b = binder.get(key);
if (b == null) {
resetContext();
return null; // normal, not found
}
if (b.nested == null) {
resetContext();
return b.loadAction(); // found real action
} else {
return new AbstractAction() {
public void actionPerformed(ActionEvent e) {
shiftContext(key); // entering submap
}
};
}
}
/**
* @param ch the specified key character
* @param modifiers the modifier mask from the event
* @return a key stroke or {@code null} if {@code ch} is undefined
*/
private static KeyStroke getKeyStroke(char ch, int modifiers) {
return KeyEvent.CHAR_UNDEFINED == ch ? null : KeyStroke.getKeyStroke(Character.valueOf(ch), modifiers);
}