/// <summary>
/// If this function returns true, there will be no attemt to decode the key press
/// via ToUnicode to reveal Strg+Alt+E = € .
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
bool CheckIsNoUnicodekey(KeyboardRawEventArgs e)
{
Keys[] NoUnicodeKeys = { Keys.Cancel, Keys.Tab, Keys.LineFeed, Keys.Clear,
Keys.Enter, Keys.Return, Keys.ShiftKey, Keys.ControlKey, Keys.Menu,
Keys.Pause, Keys.CapsLock, Keys.Capital, Keys.KanaMode, Keys.HanguelMode,
Keys.HangulMode, Keys.JunjaMode, Keys.FinalMode, Keys.KanjiMode, Keys.HanjaMode,
Keys.Escape, Keys.IMEConvert, Keys.IMENonconvert, Keys.IMEAceept, Keys.IMEAccept,
Keys.IMEModeChange, Keys.Space, Keys.Prior, Keys.PageUp, Keys.Next,
Keys.PageDown, Keys.End, Keys.Home, Keys.Left, Keys.Up, Keys.Right,
Keys.Down, Keys.Select, Keys.Print, Keys.Execute, Keys.PrintScreen,
Keys.Snapshot, Keys.Insert, Keys.Delete, Keys.Help,
Keys.LWin, Keys.RWin, Keys.Apps, Keys.Sleep,
Keys.Multiply, Keys.Add, Keys.Separator, Keys.Subtract, Keys.Decimal,
Keys.Divide, Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, Keys.F6,
Keys.F7, Keys.F8, Keys.F9, Keys.F10, Keys.F11, Keys.F12, Keys.F13,
Keys.F14, Keys.F15, Keys.F16, Keys.F17, Keys.F18, Keys.F19, Keys.F20,
Keys.F21, Keys.F22, Keys.F23, Keys.F24, Keys.NumLock, Keys.Scroll,
Keys.LShiftKey, Keys.RShiftKey, Keys.LControlKey, Keys.RControlKey,
Keys.LMenu, Keys.RMenu, Keys.BrowserBack, Keys.BrowserForward,
Keys.BrowserRefresh, Keys.BrowserStop, Keys.BrowserSearch,
Keys.BrowserFavorites, Keys.BrowserHome, Keys.VolumeMute, Keys.VolumeDown,
Keys.VolumeUp, Keys.MediaNextTrack, Keys.MediaPreviousTrack, Keys.MediaStop,
Keys.MediaPlayPause, Keys.LaunchMail, Keys.SelectMedia, Keys.LaunchApplication1,
Keys.LaunchApplication2, Keys.ProcessKey,
Keys.Packet, Keys.Attn, Keys.Crsel, Keys.Exsel, Keys.EraseEof, Keys.Play,
Keys.Zoom, Keys.NoName, Keys.Pa1, Keys.OemClear, Keys.KeyCode, Keys.Shift,
Keys.Control, Keys.Alt };
return(NoUnicodeKeys.Contains((Keys)e.vkCode));
}
public static string ParseViaToAscii(KeyboardRawEventArgs e)
{
byte[] inBuffer = new byte[2];
int buffertype = NativeMethodsKeyboard.ToAscii(e.vkCode,
e.Kbdllhookstruct.scanCode,
e.keyState,
inBuffer,
e.Alt ? 1 : 0);
if (buffertype < 0) // deadkey
{
}
else if (buffertype == 1) // one char in inBuffer[0]
{
char key = (char)inBuffer[0];
return(key.ToString());
}
else if (buffertype == 2) // two chars in inBuffer
{
char key = (char)inBuffer[0];
char key2 = (char)inBuffer[1];
return(key.ToString() + key2.ToString());
}
else if (buffertype == 0)
{
// no translation
}
return("");
}
public static string ProcessDeadkeyWithNextKey(KeyboardRawEventArgs dead, KeyboardRawEventArgs e)
{
Log.e("KP", " ProcessDeadkeyWithNextKey ");
StringBuilder inBuffer = new StringBuilder(128);
int buffertype = NativeMethodsKeyboard.ToUnicode(dead.vkCode,
dead.Kbdllhookstruct.scanCode,
dead.keyState,
inBuffer,
128,
(uint)(dead.Alt ? 1 : 0));
Log.e("KP", " FirstBuffertype " + buffertype.ToString());
buffertype = NativeMethodsKeyboard.ToUnicode(e.vkCode,
e.Kbdllhookstruct.scanCode,
e.keyState,
inBuffer,
128,
(uint)(e.Alt ? 1 : 0));
Log.e("KP", " SecondBuffertype " + buffertype.ToString());
Log.e("KP",
String.Format(" ToUnicode: bl {0} str {1} alt {2} vk {3}", buffertype,
inBuffer.ToString(), e.Alt, e.vkCode));
if (buffertype >= 1) // buffertype chars in inBuffer[0..buffertype]
{
return(inBuffer.ToString(0, buffertype));
}
else if (buffertype == 0)
{
// no translation
}
return("");
}
public static string ParseViaMapKeycode(KeyboardRawEventArgs e)
{
uint r = NativeMethodsKeyboard.MapVirtualKey((uint)e.vkCode,
NativeMethodsKeyboard.MAPVK_VK_TO_CHAR);
return(((char)r).ToString());
}
/// <summary>
/// Raises the KeyEvent event.
/// </summary>
/// <param name="e">An instance of KeyboardRawEvent</param>
public void OnKeyEvent(KeyboardRawEventArgs e)
{
if (KeyEvent != null)
{
KeyEvent(e);
}
}
public static string ParseViaToUnicode(KeyboardRawEventArgs e)
{
StringBuilder inBuffer = new StringBuilder(128);
int buffertype = NativeMethodsKeyboard.ToUnicode(e.vkCode,
e.Kbdllhookstruct.scanCode,
e.keyState,
inBuffer,
128,
(uint)(e.Alt ? 1 : 0));
Log.e("KP", " FirstBuffertype " + buffertype.ToString());
Log.e("KP",
String.Format(" ToUnicode: bl {0} str {1} alt {2} vk {3}", buffertype,
inBuffer.ToString(), e.Alt, e.vkCode));
string keystate = "";
for (int i = 0; i < e.keyState.Length; i++)
{
if (e.keyState[i] != 0)
{
keystate += " " + ((WindowsVirtualKey)i).ToString() + ":" + e.keyState[i];
}
}
Log.e("KP", " : " + keystate);
// call ToUnicode again, otherwise it will destoy the dead key for the rest of the system
int buffertype2 = NativeMethodsKeyboard.ToUnicode(e.vkCode,
e.Kbdllhookstruct.scanCode,
e.keyState,
inBuffer,
128,
(uint)(e.Alt ? 1 : 0));
Log.e("KP", " SecondBuffertype " + buffertype2.ToString() + " & deadkey");
if (buffertype < 0) // deadkey
{
// return DEADKEY, so the next key can try to assemble the deadkey
//return "DEADKEY";
return(buffertype2 >= 1 ? inBuffer.ToString(0, 1) : "");
}
else if (buffertype2 < 0) // type two dead keys in a row
{
Log.e("KP", " TwoDeadKeysInARow " + buffertype2.ToString() + " & deadkey");
return(buffertype >= 1 ? inBuffer.ToString(0, 1) : "");
}
else if (buffertype2 >= 1) // buffertype chars in inBuffer[0..buffertype]
{
return(inBuffer.ToString(0, buffertype2));
}
else if (buffertype2 == 0)
{
// no translation
}
return("");
}
bool CheckVkCodeIsModifier(KeyboardRawEventArgs e)
{
Keys[] ModifierKeys = { Keys.ControlKey, Keys.LControlKey, Keys.RControlKey,
Keys.ShiftKey, Keys.LShiftKey, Keys.RShiftKey,
Keys.LWin, Keys.RWin,
Keys.Menu, Keys.LMenu, Keys.RMenu,
Keys.NumLock, Keys.Scroll,
Keys.CapsLock };
return(ModifierKeys.Contains((Keys)e.vkCode));
}
/// <summary>
/// Checks whether Alt, Shift, Control or CapsLock
/// is enabled at the same time as another key.
/// Modify the relevant sections and return type
/// depending on what you want to do with modifier keys.
/// </summary>
private void CheckModifiers(KeyboardRawEventArgs e)
{
e.Shift = CheckModifierDown(Keys.ShiftKey);
e.Ctrl = CheckModifierDown(Keys.ControlKey);
e.Alt = CheckModifierDown(Keys.Menu);
e.Caps = CheckModifierToggled(Keys.CapsLock);
e.LWin = CheckModifierDown(Keys.LWin);
e.RWin = CheckModifierDown(Keys.RWin);
e.Numlock = CheckModifierToggled(Keys.NumLock);
e.Scrollock = CheckModifierToggled(Keys.Scroll);
e.LShift = CheckModifierDown(Keys.LShiftKey);
e.RShift = CheckModifierDown(Keys.RShiftKey);
e.LCtrl = CheckModifierDown(Keys.LControlKey);
e.RCtrl = CheckModifierDown(Keys.RControlKey);
e.LAlt = CheckModifierDown(Keys.LMenu);
e.RAlt = CheckModifierDown(Keys.RMenu);
}
public static string Parse(KeyboardRawEventArgs e)
{
StringBuilder sb = new StringBuilder(128);
int lParam = 0;
// Bits in lParam
// 16-23 Scan code.
// 24 Extended-key flag. Distinguishes some keys on an enhanced keyboard.
// 25 "Do not care" bit. The application calling this function sets this
// bit to indicate that the function should not distinguish between left
// and right CTRL and SHIFT keys, for example.
lParam = e.Kbdllhookstruct.scanCode << 16;
int result = NativeMethodsKeyboard.GetKeyNameText(lParam, sb, 128);
return(sb.ToString());
}
public KeystrokeEventArgs(KeyboardRawEventArgs e)
: base(e.Kbdllhookstruct)
{
this.Shift = e.Shift;
this.LShift = e.LShift;
this.RShift = e.RShift;
this.Ctrl = e.Ctrl;
this.LCtrl = e.LCtrl;
this.RCtrl = e.RCtrl;
this.Caps = e.Caps;
this.LWin = e.LWin;
this.RWin = e.RWin;
this.Alt = e.Alt;
this.LAlt = e.LAlt;
this.RAlt = e.RAlt;
this.Numlock = e.Numlock;
this.Scrollock = e.Scrollock;
//this.Kbdllhookstruct = e.Kbdllhookstruct;
this.keyState = e.keyState;
this.Method = e.Method;
}
private void FixKeyStateArray(KeyboardRawEventArgs e)
{
if (e.Uppercase)
{
e.keyState[(int)Keys.ShiftKey] = 129;
}
return;
e.keyState[(int)Keys.LShiftKey] = (byte)(e.LShift ? 129 : 1);
e.keyState[(int)Keys.RShiftKey] = (byte)(e.RShift ? 129 : 1);
e.keyState[(int)Keys.CapsLock] = (byte)(e.Caps ? 129 : 1);
e.keyState[(int)Keys.ControlKey] = (byte)(e.Ctrl ? 129 : 1);
e.keyState[(int)Keys.Menu] = (byte)(e.Alt ? 129 : 1);
e.keyState[(int)Keys.LWin] = (byte)(e.LWin ? 129 : 1);
e.keyState[(int)Keys.RWin] = (byte)(e.RWin ? 129 : 1);
e.keyState[(int)Keys.NumLock] = (byte)(e.Numlock ? 129 : 1);
e.keyState[(int)Keys.Scroll] = (byte)(e.Scrollock ? 129 : 1);
e.keyState[(int)Keys.LControlKey] = (byte)(e.LCtrl ? 129 : 1);
e.keyState[(int)Keys.RControlKey] = (byte)(e.RCtrl ? 129 : 1);
e.keyState[(int)Keys.LMenu] = (byte)(e.LAlt ? 129 : 1);
e.keyState[(int)Keys.RMenu] = (byte)(e.RAlt ? 129 : 1);
}
/// <summary>
/// Processes the key event captured by the hook.
/// </summary>
private IntPtr HookCallback(int nCode,
IntPtr wParam,
ref NativeMethodsKeyboard.KBDLLHOOKSTRUCT lParam)
{
if (nCode >= 0)
{
KeyboardRawEventArgs e = new KeyboardRawEventArgs(lParam);
e.keyState = new byte[256];
NativeMethodsKeyboard.GetKeyboardState(e.keyState);
if (wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
{
e.Method = KeyUpDown.Down;
}
else if (wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYUP)
{
e.Method = KeyUpDown.Up;
}
if (e.Method != KeyUpDown.Undefined)
{
CheckModifiers(e);
FixKeyStateArray(e);
Log.e("KE", "EVENT " + e.Method.ToString() + " shift:" + e.Uppercase.ToString());
OnKeyEvent(e);
}
/*System.Diagnostics.Debug.WriteLine(
* String.Format("Key: sc {0} vk {1} ext {2} fl {3}, {4}", lParam.scanCode,
* lParam.vkCode, lParam.dwExtraInfo, lParam.flags, e.Method));
*/
}
//Pass key to next application
IntPtr ret = NativeMethodsKeyboard.CallNextHookEx(hookID, nCode, wParam, ref lParam);
return(ret);
}
bool CheckIsFunctionKey(KeyboardRawEventArgs e)
{
return((int)Keys.F1 <= e.vkCode && e.vkCode <= (int)Keys.F24);
}
bool CheckIsNumericFromNumbers(KeyboardRawEventArgs e)
{
return(CheckIsNumericFromNumbers(e.vkCode));
}
bool CheckIsAlpha(KeyboardRawEventArgs e)
{
return(CheckIsAlpha(e.vkCode));
}
/// <summary>
/// Gets a KeyboardRawKeyEvent, parses it and forwards it via
/// the KeystrokeEvent
/// </summary>
/// <param name="e"></param>
void hook_KeyEvent(KeyboardRawEventArgs raw_e)
{
KeystrokeEventArgs e = new KeystrokeEventArgs(raw_e);
e.IsAlpha = CheckIsAlpha(e);
e.IsNumericFromNumpad = CheckIsNumericFromNumpad(e);
e.IsNumericFromNumbers = CheckIsNumericFromNumbers(e);
e.IsNoUnicodekey = CheckIsNoUnicodekey(e);
e.IsFunctionKey = CheckIsFunctionKey(e);
e.ModifierToggledEvent = CheckVkCodeIsModifier(e);
Log.e("KP", " alpha:" + e.IsAlpha.ToString());
if (e.Method == KeyUpDown.Down)
{
ApplyDeadKey(e);
if (e.IsAlpha && e.OnlyShiftOrCaps)
{
e.KeyString = ParseChar(e);
e.ShouldBeDisplayed = true;
e.StrokeType = KeystrokeType.Text;
e.Deletable = true;
Log.e("KP", " IsAlpha and OnlyShiftOrCaps > ParseChar");
}
else if (e.IsNumeric && e.NoModifiers)
{
e.KeyString = ParseNumeric(e);
e.ShouldBeDisplayed = true;
e.StrokeType = KeystrokeType.Text;
e.Deletable = true;
Log.e("KP", " e.IsNumeric && e.NoModifiers > ParseNumeric");
}
else if (e.ModifierToggledEvent) // vkcode is modifier
{
e.ShouldBeDisplayed = false;
AddModifier((Keys)e.vkCode, e);
e.StrokeType = KeystrokeType.Modifiers;
Log.e("KP", " e.ModifierToggledEvent > AddModifier " + ((Keys)e.vkCode).ToString());
}
else if (e.IsNoUnicodekey && e.NoModifiers)
{
ParseTexttViaSpecialkeysParser(e);
e.Deletable = IsDeletableSpecialKey(e.Key);
Log.e("KP", " e.IsNoUnicodekey && e.NoModifiers > ParseTexttViaSpecialkeysParser ");
}
else if (e.IsNoUnicodekey && !e.NoModifiers) // Shortcut
{
ParseShortcutViaSpecialkeysParser(e);
Log.e("KP", " e.IsNoUnicodekey && !e.NoModifiers > ParseShortcutViaSpecialkeysParser ");
}
else if (e.NoModifiers) // Simple Key, but not alphanumeric (first try special then unicode)
{
Log.e("KP", " e.NoModifiers > try SpecialkeysParser.ToString ");
try
{
e.KeyString = SpecialkeysParser.ToString((Keys)e.vkCode);
}
catch (NotImplementedException)
{
Log.e("KP", " e.NoModifiers 2> try KeyboardLayoutParser.ParseViaToUnicode ");
e.KeyString = KeyboardLayoutParser.ParseViaToUnicode(e);
BackupDeadKey(e);
}
e.ShouldBeDisplayed = true;
e.StrokeType = KeystrokeType.Text;
e.RequiresNewLineAfterwards = (Keys)e.vkCode == Keys.Return;
}
else if (e.OnlyShiftOrCaps) // special char, but only Shifted, eg ;:_ÖÄ'*ÜP
// (e.IsNoUnicodekey is always false here -> could be a unicode key combinatin)
{
e.KeyString = KeyboardLayoutParser.ParseViaToUnicode(e);
BackupDeadKey(e);
Log.e("KP", " e.OnlyShiftOrCaps > try KeyboardLayoutParser.ParseViaToUnicode ");
if (e.KeyString != "")
{
e.ShouldBeDisplayed = true;
e.StrokeType = KeystrokeType.Text;
e.Deletable = true;
}
else
{
// Is no unicode key combination? maybe a shortcut then: Shift + F2
ParseShortcutViaSpecialkeysParser(e);
Log.e("KP", " e.OnlyShiftOrCaps 2> ParseShortcutViaSpecialkeysParser ");
}
}
else if (!e.NoModifiers && !e.OnlyShiftOrCaps) // Special Char with Strg + Alt
// or shortcut else
{
// could be something like the german @ (Ctrl + Alt + Q)
// Temporary disabled because ToUnicode returns more often values than it should
e.KeyString = ""; //KeyboardLayoutParser.ParseViaToUnicode(e);
Log.e("KP", " !e.NoModifiers && !e.OnlyShiftOrCapss > KeyboardLayoutParser.ParseViaToUnicode");
// all other special char keycodes do not use Shift
if (e.KeyString != "" && !e.Shift && !e.IsNoUnicodekey)
{
e.ShouldBeDisplayed = true;
e.StrokeType = KeystrokeType.Text;
e.Deletable = true;
}
else // Shortcut
{
ParseShortcutViaSpecialkeysParser(e);
string possibleChar = KeyboardLayoutParser.ParseViaToUnicode(e);
BackupDeadKey(e);
if (possibleChar != "" && !CheckIsAlpha(possibleChar) &&
!CheckIsNumeric(possibleChar) &&
CheckIsASCII(possibleChar))
{
e.KeyString += " (" + possibleChar + ")";
}
Log.e("KP", " !e.NoModifiers && !e.OnlyShiftOrCapss 2> ParseShortcutViaSpecialkeysParser ");
}
}
Log.e("KP", " str:" + e.KeyString);
}
if (e.Method == KeyUpDown.Up)
{
if (e.ModifierToggledEvent) // vkcode is modifier
{
e.ShouldBeDisplayed = false;
RemoveModifier((Keys)e.vkCode, e);
e.StrokeType = KeystrokeType.Modifiers;
}
Log.e("KP", " code:" + ((Keys)e.vkCode).ToString());
// only react to modifiers on key up, nothing else
}
if (e.StrokeType != KeystrokeType.Undefined)
{
OnKeystrokeEvent(e);
}
}
