// # It is not possible to distinguish Keys.LControlKey and Keys.RControlKey when they are modifiers
// Check for Keys.Control instead
// Same for Shift and Alt(Menu)
// See more at http://www.tech-archive.net/Archive/DotNet/microsoft.public.dotnet.framework.windowsforms/2008-04/msg00127.html #
private static Keys AppendModifierStates(Keys keyData)
{
// Is Control being held down?
bool control = ((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_LCONTROL) & 0x80) != 0) ||
((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_RCONTROL) & 0x80) != 0);
// Is Shift being held down?
bool shift = ((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_LSHIFT) & 0x80) != 0) ||
((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_RSHIFT) & 0x80) != 0);
// Is Alt being held down?
bool alt = ((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_LMENU) & 0x80) != 0) ||
((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_RMENU) & 0x80) != 0);
// Windows keys
bool winL = ((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_LWIN) & 0x80) != 0);
bool winR = ((KeyboardNativeMethods.GetKeyState(KeyboardNativeMethods.VK_RWIN) & 0x80) != 0);
// Function (Fn) key
// # CANNOT determine state due to conversion inside keyboard
// See http://en.wikipedia.org/wiki/Fn_key#Technical_details #
return(keyData |
(control ? Keys.Control : Keys.None) |
(shift ? Keys.Shift : Keys.None) |
(alt ? Keys.Alt : Keys.None) |
(winL ? Keys.LWin : Keys.None) |
(winR ? Keys.RWin : Keys.None));
}
/// <summary>
/// Creates <see cref="KeyPressEventArgsExt"/> from Windows Message parameters,
/// based upon a system-wide hook.
/// </summary>
/// <param name="wParam">The first Windows Message parameter.</param>
/// <param name="lParam">The second Windows Message parameter.</param>
/// <returns>A new KeyPressEventArgsExt object.</returns>
internal static KeyPressEventArgsExt FromRawDataGlobal(int wParam, IntPtr lParam)
{
if (wParam != Messages.WM_KEYDOWN)
{
return(new KeyPressEventArgsExt((char)0));
}
KeyboardHookStruct keyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
int virtualKeyCode = keyboardHookStruct.VirtualKeyCode;
int scanCode = keyboardHookStruct.ScanCode;
int fuState = keyboardHookStruct.Flags;
char ch;
if (virtualKeyCode == KeyboardNativeMethods.VK_PACKET)
{
ch = (char)scanCode;
}
else
{
bool isSuccessfull = KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out ch);
if (!isSuccessfull)
{
return(new KeyPressEventArgsExt((char)0));
}
}
KeyPressEventArgsExt e = new KeyPressEventArgsExt(ch, keyboardHookStruct.Time);
return(e);
}
/// <summary>
/// Makes a snapshot of a keyboard state to the moment of call and returns an
/// instance of <see cref="KeyboardState" /> class.
/// </summary>
/// <returns>An instance of <see cref="KeyboardState" /> class representing a snapshot of keyboard state at certain moment.</returns>
public static KeyboardState GetCurrent()
{
var keyboardStateNative = new byte[256];
KeyboardNativeMethods.GetKeyboardState(keyboardStateNative);
return(new KeyboardState(keyboardStateNative));
}
internal static IEnumerable <EventArgsExtTuşBasımı> FromRawDataApp(CallbackData data)
{
var wParam = data.WParam;
var lParam = data.LParam;
const uint maskKeydown = 0x40000000;
const uint maskKeyup = 0x80000000;
const uint maskScanCode = 0xff0000;
var flags = (uint)lParam.ToInt64();
var wasKeyDown = (flags & maskKeydown) > 0;
var isKeyReleased = (flags & maskKeyup) > 0;
if (!wasKeyDown && !isKeyReleased)
{
yield break;
}
var virtualKeyCode = (int)wParam;
var scanCode = checked ((int)(flags & maskScanCode));
const int fuState = 0;
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield break;
}
foreach (var ch in chars)
{
yield return(new EventArgsExtTuşBasımı(ch));
}
}
/// <summary>
/// Makes a snapshot of a keyboard state to the moment of call and returns an
/// instance of <see cref="KeyboardState" /> class.
/// </summary>
/// <returns>An instance of <see cref="KeyboardState" /> class representing a snapshot of keyboard state at certain moment.</returns>
public static KeyboardState GetCurrent()
{
var bytes = new byte[256];
accessor.ReadArray <byte>(0, bytes, 0, 256);
HandledDownKeys = new KeyboardState(bytes);
var keyboardStateNative = new byte[256];
KeyboardNativeMethods.GetKeyboardState(keyboardStateNative);
return(new KeyboardState(keyboardStateNative));
}
/// <summary>
/// Creates <see cref="KeyPressEventArgsExt"/> from Windows Message parameters,
/// based upon a local application hook.
/// </summary>
/// <param name="wParam">The first Windows Message parameter.</param>
/// <param name="lParam">The second Windows Message parameter.</param>
/// <returns>A new KeyPressEventArgsExt object.</returns>
private static KeyPressEventArgsExt FromRawDataApp(int wParam, IntPtr lParam)
{
//http://msdn.microsoft.com/en-us/library/ms644984(v=VS.85).aspx
const uint maskKeydown = 0x40000000; // for bit 30
const uint maskKeyup = 0x80000000; // for bit 31
const uint maskScanCode = 0xff0000; // for bit 23-16
uint flags = 0u;
#if IS_X64
// both of these are ugly hacks. Is there a better way to convert a 64bit IntPtr to uint?
// flags = uint.Parse(lParam.ToString());
flags = Convert.ToUInt32(lParam.ToInt64());
#else
//updated from ( uint )lParam, which threw an integer overflow exception in unicode characters
flags = ( uint )lParam.ToInt64();
#endif
//bit 30 Specifies the previous key state. The value is 1 if the key is down before the message is sent; it is 0 if the key is up.
bool wasKeyDown = (flags & maskKeydown) > 0;
//bit 31 Specifies the transition state. The value is 0 if the key is being pressed and 1 if it is being released.
bool isKeyReleased = (flags & maskKeyup) > 0;
if (!wasKeyDown && !isKeyReleased)
{
return(new KeyPressEventArgsExt((char)0));
}
int virtualKeyCode = wParam;
int scanCode = checked ((int)(flags & maskScanCode));
const int fuState = 0;
char ch;
if (virtualKeyCode == KeyboardNativeMethods.VK_PACKET)
{
ch = ( char )scanCode;
}
else
{
bool isSuccessfull = KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out ch);
if (!isSuccessfull)
{
return(new KeyPressEventArgsExt(( char )0));
}
}
return(new KeyPressEventArgsExt(ch));
}
internal static IEnumerable <KeyPressEventArgsExt> FromRawDataGlobal(CallbackData data)
{
var wParam = data.WParam;
var lParam = data.LParam;
if ((int)wParam != Messages.WM_KEYDOWN && (int)wParam != Messages.WM_SYSKEYDOWN)
{
yield break;
}
KeyboardHookStruct keyboardHookStruct =
(KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
var virtualKeyCode = keyboardHookStruct.VirtualKeyCode;
var scanCode = keyboardHookStruct.ScanCode;
var fuState = keyboardHookStruct.Flags;
if (virtualKeyCode == KeyboardNativeMethods.VK_PACKET)
{
var ch = (char)scanCode;
yield return(new KeyPressEventArgsExt(ch, keyboardHookStruct.Time, new VirtualKeyCode
{
virtualKeyCode = virtualKeyCode,
scanCode = scanCode
}));
}
else
{
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield return(new KeyPressEventArgsExt(null, keyboardHookStruct.Time, new VirtualKeyCode
{
virtualKeyCode = virtualKeyCode,
scanCode = scanCode
}));
}
else
{
foreach (var current in chars)
{
yield return(new KeyPressEventArgsExt(current, keyboardHookStruct.Time, new VirtualKeyCode
{
virtualKeyCode = virtualKeyCode,
scanCode = scanCode
}));
}
}
}
}
/// <summary>
/// Creates <see cref="KeyEventArgsExt"/> from Windows Message parameters, based upon
/// a system-wide hook.
/// </summary>
/// <param name="wParam">The first Windows Message parameter.</param>
/// <param name="lParam">The second Windows Message parameter.</param>
/// <returns>A new KeyEventArgsExt object.</returns>
private static KeyEventArgsExt FromRawDataGlobal(int wParam, IntPtr lParam)
{
KeyboardHookStruct keyboardHookStruct = ( KeyboardHookStruct )Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
Keys keyData = AppendModifierStates(( Keys )keyboardHookStruct.VirtualKeyCode);
bool isKeyDown = (wParam == Messages.WM_KEYDOWN || wParam == Messages.WM_SYSKEYDOWN);
bool isKeyUp = (wParam == Messages.WM_KEYUP || wParam == Messages.WM_SYSKEYUP);
//sent explicitly as a Unicode character
if (keyboardHookStruct.VirtualKeyCode == KeyboardNativeMethods.VK_PACKET)
{
return(new KeyEventArgsExt(keyData, keyboardHookStruct.Time, isKeyDown, isKeyUp, ( char )AppendModifierStates(( Keys )keyboardHookStruct.ScanCode)));
}
//Translate based on the application's keyboard layout
char ch;
KeyboardNativeMethods.TryGetCharFromKeyboardState(keyboardHookStruct.VirtualKeyCode, keyboardHookStruct.ScanCode, keyboardHookStruct.Flags, out ch);
return(new KeyEventArgsExt(keyData, keyboardHookStruct.Time, isKeyDown, isKeyUp, ch));
}
internal static IEnumerable <KeyPressEventArgsExt> FromRawDataApp(CallbackData data, IKeyEventArgs arg)
{
var wParam = data.WParam;
var lParam = data.LParam;
//http://msdn.microsoft.com/en-us/library/ms644984(v=VS.85).aspx
const uint maskKeydown = 0x40000000; // for bit 30
const uint maskKeyup = 0x80000000; // for bit 31
const uint maskScanCode = 0xff0000; // for bit 23-16
var flags = (uint)lParam.ToInt64();
//bit 30 Specifies the previous key state. The value is 1 if the key is down before the message is sent; it is 0 if the key is up.
var wasKeyDown = (flags & maskKeydown) > 0;
//bit 31 Specifies the transition state. The value is 0 if the key is being pressed and 1 if it is being released.
var isKeyReleased = (flags & maskKeyup) > 0;
if (!wasKeyDown && !isKeyReleased)
{
yield break;
}
var virtualKeyCode = (int)wParam;
var scanCode = checked ((int)(flags & maskScanCode));
const int fuState = 0;
char[] chars;
KeyboardNativeMethods.TryGetCharFromKeyboardState(virtualKeyCode, scanCode, fuState, out chars);
if (chars == null)
{
yield break;
}
foreach (var ch in chars)
{
yield return(new KeyPressEventArgsExt(ch, arg));
}
}
/// <summary>
/// Creates <see cref="KeyEventArgsExt"/> from Windows Message parameters, based upon
/// a local application hook.
/// </summary>
/// <param name="wParam">The first Windows Message parameter.</param>
/// <param name="lParam">The second Windows Message parameter.</param>
/// <returns>A new KeyEventArgsExt object.</returns>
private static KeyEventArgsExt FromRawDataApp(int wParam, IntPtr lParam)
{
//http://msdn.microsoft.com/en-us/library/ms644984(v=VS.85).aspx
const uint maskKeydown = 0x40000000; // for bit 30
const uint maskKeyup = 0x80000000; // for bit 31
int timestamp = Environment.TickCount;
uint flags = 0u;
#if IS_X64
// both of these are ugly hacks. Is there a better way to convert a 64bit IntPtr to uint?
// flags = uint.Parse(lParam.ToString());
flags = Convert.ToUInt32(lParam.ToInt64());
#else
//updated from ( uint )lParam, which threw an integer overflow exception in Unicode characters
flags = ( uint )lParam.ToInt64();
#endif
//bit 30 Specifies the previous key state. The value is 1 if the key is down before the message is sent; it is 0 if the key is up.
bool wasKeyDown = (flags & maskKeydown) > 0;
//bit 31 Specifies the transition state. The value is 0 if the key is being pressed and 1 if it is being released.
bool isKeyReleased = (flags & maskKeyup) > 0;
Keys keyData = AppendModifierStates(( Keys )wParam);
bool isKeyDown = !wasKeyDown && !isKeyReleased;
bool isKeyUp = wasKeyDown && isKeyReleased;
char ch;
//translated based on the active application's keyboard layout.
KeyboardNativeMethods.TryGetCharFromKeyboardState(wParam, ( int )flags, out ch);
return(new KeyEventArgsExt(keyData, timestamp, isKeyDown, isKeyUp, ch));
}
// Token: 0x060002D8 RID: 728 RVA: 0x0000357F File Offset: 0x0000177F
private static bool CheckModifier(int vKey)
{
return(((int)KeyboardNativeMethods.GetKeyState(vKey) & 32768) > 0);
}
// # It is not possible to distinguish Keys.LControlKey and Keys.RControlKey when they are modifiers
// Check for Keys.Control instead
// Same for Shift and Alt(Menu)
// See more at http://www.tech-archive.net/Archive/DotNet/microsoft.public.dotnet.framework.windowsforms/2008-04/msg00127.html #
// A shortcut to make life easier
private static bool CheckModifier(int vKey)
{
return((KeyboardNativeMethods.GetKeyState(vKey) & 0x8000) > 0);
}
// Token: 0x060002C2 RID: 706 RVA: 0x0000E8A0 File Offset: 0x0000CAA0
public static KeyboardState GetCurrent()
{
byte[] array = new byte[256];
KeyboardNativeMethods.GetKeyboardState(array);
return(new KeyboardState(array));
}
