| public static KeyFromVirtualKey ( int virtualKey ) : Key | ||
| virtualKey | int | |
| return | Key | |
public static Key KeyFromVirtualKey(int virtualKey)
{
Key key = Key.None;
switch(virtualKey)
{
case VK_CANCEL:
key = Key.Cancel;
break;
case VK_BACK:
key = Key.Back;
break;
case VK_TAB:
key = Key.Tab;
break;
case VK_CLEAR:
key = Key.Clear;
break;
case VK_RETURN:
key = Key.Return;
break;
case VK_PAUSE:
key = Key.Pause;
break;
case VK_CAPITAL:
key = Key.Capital;
break;
case VK_KANA:
key = Key.KanaMode;
break;
case VK_JUNJA:
key = Key.JunjaMode;
break;
case VK_FINAL:
key = Key.FinalMode;
break;
case VK_KANJI:
key = Key.KanjiMode;
break;
case VK_ESCAPE:
key = Key.Escape;
break;
case VK_CONVERT:
key = Key.ImeConvert;
break;
case VK_NONCONVERT:
key = Key.ImeNonConvert;
break;
case VK_ACCEPT:
key = Key.ImeAccept;
break;
case VK_MODECHANGE:
key = Key.ImeModeChange;
break;
case VK_SPACE:
key = Key.Space;
break;
case VK_PRIOR:
key = Key.Prior;
break;
case VK_NEXT:
key = Key.Next;
break;
case VK_END:
key = Key.End;
break;
case VK_HOME:
key = Key.Home;
break;
case VK_LEFT:
key = Key.Left;
break;
case VK_UP:
key = Key.Up;
break;
case VK_RIGHT:
key = Key.Right;
break;
case VK_DOWN:
key = Key.Down;
break;
case VK_SELECT:
key = Key.Select;
break;
case VK_PRINT:
key = Key.Print;
break;
case VK_EXECUTE:
key = Key.Execute;
break;
case VK_SNAPSHOT:
key = Key.Snapshot;
break;
case VK_INSERT:
key = Key.Insert;
break;
case VK_DELETE:
key = Key.Delete;
break;
case VK_HELP:
key = Key.Help;
break;
case VK_0:
key = Key.D0;
break;
case VK_1:
key = Key.D1;
break;
case VK_2:
key = Key.D2;
break;
case VK_3:
key = Key.D3;
break;
case VK_4:
key = Key.D4;
break;
case VK_5:
key = Key.D5;
break;
case VK_6:
key = Key.D6;
break;
case VK_7:
key = Key.D7;
break;
case VK_8:
key = Key.D8;
break;
case VK_9:
key = Key.D9;
break;
case VK_A:
key = Key.A;
break;
case VK_B:
key = Key.B;
break;
case VK_C:
key = Key.C;
break;
case VK_D:
key = Key.D;
break;
case VK_E:
key = Key.E;
break;
case VK_F:
key = Key.F;
break;
case VK_G:
key = Key.G;
break;
case VK_H:
key = Key.H;
break;
case VK_I:
key = Key.I;
break;
case VK_J:
key = Key.J;
break;
case VK_K:
key = Key.K;
break;
case VK_L:
key = Key.L;
break;
case VK_M:
key = Key.M;
break;
case VK_N:
key = Key.N;
break;
case VK_O:
key = Key.O;
break;
case VK_P:
key = Key.P;
break;
case VK_Q:
key = Key.Q;
break;
case VK_R:
key = Key.R;
break;
case VK_S:
key = Key.S;
break;
case VK_T:
key = Key.T;
break;
case VK_U:
key = Key.U;
break;
case VK_V:
key = Key.V;
break;
case VK_W:
key = Key.W;
break;
case VK_X:
key = Key.X;
break;
case VK_Y:
key = Key.Y;
break;
case VK_Z:
key = Key.Z;
break;
case VK_LWIN:
key = Key.LWin;
break;
case VK_RWIN:
key = Key.RWin;
break;
case VK_APPS:
key = Key.Apps;
break;
case VK_SLEEP:
key = Key.Sleep;
break;
case VK_NUMPAD0:
key = Key.NumPad0;
break;
case VK_NUMPAD1:
key = Key.NumPad1;
break;
case VK_NUMPAD2:
key = Key.NumPad2;
break;
case VK_NUMPAD3:
key = Key.NumPad3;
break;
case VK_NUMPAD4:
key = Key.NumPad4;
break;
case VK_NUMPAD5:
key = Key.NumPad5;
break;
case VK_NUMPAD6:
key = Key.NumPad6;
break;
case VK_NUMPAD7:
key = Key.NumPad7;
break;
case VK_NUMPAD8:
key = Key.NumPad8;
break;
case VK_NUMPAD9:
key = Key.NumPad9;
break;
case VK_MULTIPLY:
key = Key.Multiply;
break;
case VK_ADD:
key = Key.Add;
break;
case VK_SEPARATOR:
key = Key.Separator;
break;
case VK_SUBTRACT:
key = Key.Subtract;
break;
case VK_DECIMAL:
key = Key.Decimal;
break;
case VK_DIVIDE:
key = Key.Divide;
break;
case VK_F1:
key = Key.F1;
break;
case VK_F2:
key = Key.F2;
break;
case VK_F3:
key = Key.F3;
break;
case VK_F4:
key = Key.F4;
break;
case VK_F5:
key = Key.F5;
break;
case VK_F6:
key = Key.F6;
break;
case VK_F7:
key = Key.F7;
break;
case VK_F8:
key = Key.F8;
break;
case VK_F9:
key = Key.F9;
break;
case VK_F10:
key = Key.F10;
break;
case VK_F11:
key = Key.F11;
break;
case VK_F12:
key = Key.F12;
break;
case VK_F13:
key = Key.F13;
break;
case VK_F14:
key = Key.F14;
break;
case VK_F15:
key = Key.F15;
break;
case VK_F16:
key = Key.F16;
break;
case VK_F17:
key = Key.F17;
break;
case VK_F18:
key = Key.F18;
break;
case VK_F19:
key = Key.F19;
break;
case VK_F20:
key = Key.F20;
break;
case VK_F21:
key = Key.F21;
break;
case VK_F22:
key = Key.F22;
break;
case VK_F23:
key = Key.F23;
break;
case VK_F24:
key = Key.F24;
break;
case VK_NUMLOCK:
key = Key.NumLock;
break;
case VK_SCROLL:
key = Key.Scroll;
break;
case VK_SHIFT:
case VK_LSHIFT:
key = Key.LeftShift;
break;
case VK_RSHIFT:
key = Key.RightShift;
break;
case VK_CONTROL:
case VK_LCONTROL:
key = Key.LeftCtrl;
break;
case VK_RCONTROL:
key = Key.RightCtrl;
break;
case VK_MENU:
case VK_LMENU:
key = Key.LeftAlt;
break;
case VK_RMENU:
key = Key.RightAlt;
break;
case VK_BROWSER_BACK:
key = Key.BrowserBack;
break;
case VK_BROWSER_FORWARD:
key = Key.BrowserForward;
break;
case VK_BROWSER_REFRESH:
key = Key.BrowserRefresh;
break;
case VK_BROWSER_STOP:
key = Key.BrowserStop;
break;
case VK_BROWSER_SEARCH:
key = Key.BrowserSearch;
break;
case VK_BROWSER_FAVORITES:
key = Key.BrowserFavorites;
break;
case VK_BROWSER_HOME:
key = Key.BrowserHome;
break;
case VK_VOLUME_MUTE:
key = Key.VolumeMute;
break;
case VK_VOLUME_DOWN:
key = Key.VolumeDown;
break;
case VK_VOLUME_UP:
key = Key.VolumeUp;
break;
case VK_MEDIA_NEXT_TRACK:
key = Key.MediaNextTrack;
break;
case VK_MEDIA_PREV_TRACK:
key = Key.MediaPreviousTrack;
break;
case VK_MEDIA_STOP:
key = Key.MediaStop;
break;
case VK_MEDIA_PLAY_PAUSE:
key = Key.MediaPlayPause;
break;
case VK_LAUNCH_MAIL:
key = Key.LaunchMail;
break;
case VK_LAUNCH_MEDIA_SELECT:
key = Key.SelectMedia;
break;
case VK_LAUNCH_APP1:
key = Key.LaunchApplication1;
break;
case VK_LAUNCH_APP2:
key = Key.LaunchApplication2;
break;
case VK_OEM_1:
key = Key.OemSemicolon;
break;
case VK_OEM_PLUS:
key = Key.OemPlus;
break;
case VK_OEM_COMMA:
key = Key.OemComma;
break;
case VK_OEM_MINUS:
key = Key.OemMinus;
break;
case VK_OEM_PERIOD:
key = Key.OemPeriod;
break;
case VK_OEM_2:
key = Key.OemQuestion;
break;
case VK_OEM_3:
key = Key.OemTilde;
break;
case VK_C1:
key = Key.AbntC1;
break;
case VK_C2:
key = Key.AbntC2;
break;
case VK_OEM_4:
key = Key.OemOpenBrackets;
break;
case VK_OEM_5:
key = Key.OemPipe;
break;
case VK_OEM_6:
key = Key.OemCloseBrackets;
break;
case VK_OEM_7:
key = Key.OemQuotes;
break;
case VK_OEM_8:
key = Key.Oem8;
break;
case VK_OEM_102:
key = Key.OemBackslash;
break;
case VK_PROCESSKEY:
key = Key.ImeProcessed;
break;
case VK_OEM_ATTN: // VK_DBE_ALPHANUMERIC
key = Key.OemAttn; // DbeAlphanumeric
break;
case VK_OEM_FINISH: // VK_DBE_KATAKANA
key = Key.OemFinish; // DbeKatakana
break;
case VK_OEM_COPY: // VK_DBE_HIRAGANA
key = Key.OemCopy; // DbeHiragana
break;
case VK_OEM_AUTO: // VK_DBE_SBCSCHAR
key = Key.OemAuto; // DbeSbcsChar
break;
case VK_OEM_ENLW: // VK_DBE_DBCSCHAR
key = Key.OemEnlw; // DbeDbcsChar
break;
case VK_OEM_BACKTAB: // VK_DBE_ROMAN
key = Key.OemBackTab; // DbeRoman
break;
case VK_ATTN: // VK_DBE_NOROMAN
key = Key.Attn; // DbeNoRoman
break;
case VK_CRSEL: // VK_DBE_ENTERWORDREGISTERMODE
key = Key.CrSel; // DbeEnterWordRegisterMode
break;
case VK_EXSEL: // VK_DBE_ENTERIMECONFIGMODE
key = Key.ExSel; // DbeEnterImeConfigMode
break;
case VK_EREOF: // VK_DBE_FLUSHSTRING
key = Key.EraseEof; // DbeFlushString
break;
case VK_PLAY: // VK_DBE_CODEINPUT
key = Key.Play; // DbeCodeInput
break;
case VK_ZOOM: // VK_DBE_NOCODEINPUT
key = Key.Zoom; // DbeNoCodeInput
break;
case VK_NONAME: // VK_DBE_DETERMINESTRING
key = Key.NoName; // DbeDetermineString
break;
case VK_PA1: // VK_DBE_ENTERDLGCONVERSIONMODE
key = Key.Pa1; // DbeEnterDlgConversionMode
break;
case VK_OEM_CLEAR:
key = Key.OemClear;
break;
default:
key = Key.None;
break;
}
return key;
}
private void PreNotifyInput(object sender, NotifyInputEventArgs e)
{
RawKeyboardInputReport keyboardInput = ExtractRawKeyboardInputReport(e, InputManager.PreviewInputReportEvent);
if (keyboardInput != null)
{
CheckForDisconnectedFocus();
// Activation
//
// MITIGATION: KEYBOARD_STATE_OUT_OF_SYNC
//
// It is very important that we allow multiple activate events.
// This is how we deal with the fact that Win32 sometimes sends
// us a WM_SETFOCUS message BEFORE it has updated it's internal
// internal keyboard state information. When we get the
// WM_SETFOCUS message, we activate the keyboard with the
// keyboard state (even though it could be wrong). Then when
// we get the first "real" keyboard input event, we activate
// the keyboard again, since Win32 will have updated the
// keyboard state correctly by then.
//
if ((keyboardInput.Actions & RawKeyboardActions.Activate) == RawKeyboardActions.Activate)
{
//if active source is null, no need to do special-case handling
if (_activeSource == null)
{
// we are now active.
_activeSource = new SecurityCriticalDataClass <PresentationSource>(keyboardInput.InputSource);
}
else if (_activeSource.Value != keyboardInput.InputSource)
{
IKeyboardInputProvider toDeactivate = _activeSource.Value.GetInputProvider(typeof(KeyboardDevice)) as IKeyboardInputProvider;
// we are now active.
_activeSource = new SecurityCriticalDataClass <PresentationSource>(keyboardInput.InputSource);
if (toDeactivate != null)
{
toDeactivate.NotifyDeactivate();
}
}
}
// Generally, we need to check against redundant actions.
// We never prevet the raw event from going through, but we
// will only generate the high-level events for non-redundant
// actions. We store the set of non-redundant actions in
// the dictionary of this event.
// If the input is reporting a key down, the action is never
// considered redundant.
if ((keyboardInput.Actions & RawKeyboardActions.KeyDown) == RawKeyboardActions.KeyDown)
{
RawKeyboardActions actions = GetNonRedundantActions(e);
actions |= RawKeyboardActions.KeyDown;
e.StagingItem.SetData(_tagNonRedundantActions, actions);
// Pass along the key that was pressed, and update our state.
Key key = KeyInterop.KeyFromVirtualKey(keyboardInput.VirtualKey);
e.StagingItem.SetData(_tagKey, key);
e.StagingItem.SetData(_tagScanCode, new ScanCode(keyboardInput.ScanCode, keyboardInput.IsExtendedKey));
// Tell the InputManager that the MostRecentDevice is us.
if (_inputManager != null)
{
_inputManager.Value.MostRecentInputDevice = this;
}
}
// We are missing detection for redundant ups
if ((keyboardInput.Actions & RawKeyboardActions.KeyUp) == RawKeyboardActions.KeyUp)
{
RawKeyboardActions actions = GetNonRedundantActions(e);
actions |= RawKeyboardActions.KeyUp;
e.StagingItem.SetData(_tagNonRedundantActions, actions);
// Pass along the key that was pressed, and update our state.
Key key = KeyInterop.KeyFromVirtualKey(keyboardInput.VirtualKey);
e.StagingItem.SetData(_tagKey, key);
e.StagingItem.SetData(_tagScanCode, new ScanCode(keyboardInput.ScanCode, keyboardInput.IsExtendedKey));
// Tell the InputManager that the MostRecentDevice is us.
if (_inputManager != null)
{
_inputManager.Value.MostRecentInputDevice = this;
}
}
}
// On KeyDown, we might need to set the Repeat flag
if (e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyDownEvent)
{
CheckForDisconnectedFocus();
KeyEventArgs args = (KeyEventArgs)e.StagingItem.Input;
// Is this the same as the previous key? (Look at the real key, e.g. TextManager
// might have changed args.Key it to Key.TextInput.)
if (_previousKey == args.RealKey)
{
// Yes, this is a repeat (we got the keydown for it twice, with no KeyUp in between)
args.SetRepeat(true);
}
// Otherwise, keep this key to check against next time.
else
{
_previousKey = args.RealKey;
args.SetRepeat(false);
}
}
// On KeyUp, we clear Repeat flag
else if (e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyUpEvent)
{
CheckForDisconnectedFocus();
KeyEventArgs args = (KeyEventArgs)e.StagingItem.Input;
args.SetRepeat(false);
// Clear _previousKey, so that down/up/down/up doesn't look like a repeat
_previousKey = Key.None;
}
}