/// <summary> Maps key input to events </summary>
RlEvent handleVKey(VKey key, VInput input)
{
var entity = this.controller.actor;
var dir = entity.get <Body>().facing;
switch (key)
{
case VKey.Select:
return(PlayerCommands.onSelectKeyPressed(entity, this.gameCtx));
case VKey.Cancel:
// this.cradle.push(new MenuControl(this.god, new InvMenu(this.god, this.context.controlled.get<Inventory>())));
break;
case VKey.Ground:
break;
case VKey.RestATurn:
break;
default:
break;
}
return(null);
}
public static bool SendInput(VKey key)
{
Press(key);
Release(key);
return(true);
}
public void KeyDown(VKey key, List <VKey> pressedKeys)
{
if (_configurationModel.Enable == DisplayOption.Counters || _configurationModel.Enable == DisplayOption.Both)
{
Shortcut shortcut = ResolveShortcut(key, pressedKeys, new List <Shortcut>()
{
_configurationModel.CounterShortcuts.Next,
_configurationModel.CounterShortcuts.Previous,
_configurationModel.CounterShortcuts.Increment,
_configurationModel.CounterShortcuts.Decrement,
_configurationModel.CounterShortcuts.Reset
});
if (shortcut != null && shortcut.Command.CanExecute(null))
{
shortcut.Command.Execute(null);
}
}
if (_configurationModel.Enable == DisplayOption.Sounds || _configurationModel.Enable == DisplayOption.Both)
{
Shortcut shortcut = ResolveShortcut(key, pressedKeys, new List <Shortcut>()
{
_configurationModel.SoundShortcuts.Pause,
_configurationModel.SoundShortcuts.Continue,
_configurationModel.SoundShortcuts.Stop
});
if (shortcut != null && shortcut.Command.CanExecute(null))
{
shortcut.Command.Execute(null);
}
}
}
private void Key_Up(VKey key)
{
KeyUp?.Invoke(key, pressedKeys);
if (pressedKeys.Contains(key))
{
pressedKeys.Remove(key);
}
}
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
/// <param name="modifiers">Key modifiers in effect.</param>
public static void KeyPress(VKey vKey, byte modifiers)
{
bool alt = Win32.CheckMask(modifiers, (byte)KeyModifiers.Alt);
bool ctrl = Win32.CheckMask(modifiers, (byte)KeyModifiers.Ctrl);
bool shift = Win32.CheckMask(modifiers, (byte)KeyModifiers.Shift);
KeyPress(vKey, alt, ctrl, shift, false);
}
public static bool SendKeyDown(IntPtr hWnd, VKey vkey, bool sys = false)
{
return(Native.SendMessage(
hWnd,
(int)(sys ? Message.SYSKEY_DOWN : Message.KEY_DOWN),
(uint)vkey, Native.GetLParam(1, vkey, 0, (byte)(sys ? 1 : 0), 0, 0)
) == 0);
}
public static bool PostKeyUp(IntPtr hWnd, VKey vkey, bool sys = false)
{
return(Native.PostMessage(
hWnd,
(int)(sys ? Message.SYSKEY_UP : Message.KEY_UP),
(uint)vkey, Native.GetLParam(1, vkey, 0, (byte)(sys ? 1 : 0), 1, 1)
));
}
private void Key_Down(VKey key)
{
if (!pressedKeys.Contains(key))
{
pressedKeys.Add(key);
KeyPress?.Invoke(key, pressedKeys);
}
KeyDown?.Invoke(key, pressedKeys);
}
public void InstertVKey(VKey vkey, string id)
{
if (_vkeyRepo.ContainsKey(id))
{
throw new System.Exception("The key " + id + " already exists.");
}
vkey.id = _vkeyRepo.Count;
_vkeyRepo.Add(id, vkey);
}
public void UpdateVKey(VKey vkey, string id)
{
if (!_vkeyRepo.ContainsKey(id))
{
throw new NoSuchKeyException();
}
vkey.name = id;
_vkeyRepo[id] = vkey;
}
public bool isDown(VKey key)
{
if (key == VKey.AxisKey)
{
return(this.vDir.isDown);
}
else
{
return(this.isKeyDown(key));
}
}
public bool isPressed(VKey key)
{
if (key == VKey.AxisKey)
{
return(this.vDir.isPressed);
}
else
{
return(this.isKeyPressed(key));
}
}
/// <summary> Consumes a specific key and returns whether it was pressed or not. </summary>
public bool consume(VKey key)
{
if (key == VKey.AxisKey)
{
return(this.consumeDir());
}
var bt = this._buttons[key];
bool result = bt.isPressed;
this._buttons[key].consumePulseBuffer();
return(result);
}
public static void KeyboardEvent(VKey keycode, bool downpress)
{
byte key = (byte)keycode;
if (downpress)
{
keybd_event(key, 0, 0, 0);
}
else
{
keybd_event(key, 0, KEYEVENTF_KEYUP, 0);
}
}
public void KeyUp(VKey key, List <VKey> pressedKeys)
{
if (_applicationStateModel.ModifiedBindable != null)
{
_applicationStateModel.ModifiedBindable.Keys.Clear();
foreach (VKey pressedKey in pressedKeys)
{
_applicationStateModel.ModifiedBindable.Keys.Add(pressedKey);
}
_applicationStateModel.BindKeysOpened = false;
_applicationStateModel.ModifiedBindable = null;
}
}
public void KeyDown(VKey key, List <VKey> pressedKeys)
{
Shortcut shortcut = ResolveShortcut(key, pressedKeys, new List <Shortcut>()
{
_configurationModel.SoundShortcuts.Pause,
_configurationModel.SoundShortcuts.Continue,
_configurationModel.SoundShortcuts.Stop
});
if (shortcut != null && shortcut.Command.CanExecute(null))
{
shortcut.Command.Execute(null);
}
}
public static uint GetLParam(Int16 repeatCount, VKey vkey, byte extended, byte contextCode,
byte previousState,
byte transitionState)
{
var lParam = (uint)repeatCount;
uint scanCode = GetScanCode(vkey);
lParam += scanCode * 0x10000;
lParam += (uint)(extended * 0x1000000);
lParam += (uint)(contextCode * 2 * 0x10000000);
lParam += (uint)(previousState * 4 * 0x10000000);
lParam += (uint)(transitionState * 8 * 0x10000000);
return(lParam);
}
public static bool PostKeyPress(IntPtr hWnd, VKey vkey, bool sys = false, int delay = 10)
{
if (!PostKeyDown(hWnd, vkey, sys))
{
return(false);
}
//Send VM_CHAR
//if (PostMessage(hWnd, (int)Message.VM_CHAR, (uint)key, GetLParam(1, key, 0, 0, 0, 0)))
// return false;
Thread.Sleep(delay);
return(PostKeyUp(hWnd, vkey, sys));
}
/// <summary>
/// Simulate a key being released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
public static void KeyUp(VKey vKey)
{
bool isExtended = IsExtendedKey(vKey);
uint scanCode = MapVirtualKey((uint)vKey, 0);
if (isExtended)
{
keybd_event((byte)vKey, (byte)scanCode, (uint)KeyEvents.KeyUp | (uint)KeyEvents.ExtendedKey, IntPtr.Zero);
}
else
{
keybd_event((byte)vKey, (byte)scanCode, (uint)KeyEvents.KeyUp, IntPtr.Zero);
}
}
public static VKey GetVirtualKey(char c, out ShiftState shift)
{
shift = ShiftState.NONE;
short result = VkKeyScanEx(c, loadedKeyboard);
if (result == -1)
{
return(VKey.UNDEFINED);
}
VKey key = (VKey)(result & 0xFF);
shift = (ShiftState)(result >> 8);
return(key);
}
public FormMacroAction(MacroAction action)
{
InitializeComponent();
Array vkeys = Enum.GetValues(typeof(VKey));
for (int i = 0; i < vkeys.Length; i++)
{
VKey key = (VKey)vkeys.GetValue(i);
cbxKeys.Items.Add(new VKeyItem(key));
if (key == VKey.F1)
{
cbxKeys.SelectedIndex = i;
}
}
if (action == null)
{
chbKey.Checked = true;
}
else
{
if (action.Delay.HasValue)
{
chbDelay.Checked = true;
nudMinutes.Value = (int)action.Delay.Value.Minutes;
nudSeconds.Value = (int)action.Delay.Value.Seconds;
nudMiliseconds.Value = (int)action.Delay.Value.Milliseconds;
}
else
{
chbKey.Checked = true;
cbxKeys.SelectedIndex = 0;
for (int i = 0; i < vkeys.Length; i++)
{
VKey key = (VKey)vkeys.GetValue(i);
if (key == action.Key.Value)
{
cbxKeys.SelectedIndex = i;
}
}
}
}
}
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="ch">Key character to simulate.</param>
public static void KeyPress(char ch)
{
short virtualKeyCode = VkKeyScan(ch);
byte modifiers = Win32.HighByte(virtualKeyCode);
VKey vKey = (VKey)Win32.LowByte(virtualKeyCode);
if (modifiers == 0)
{
KeyPress(vKey);
}
else
{
KeyPress(vKey, modifiers);
}
}
public void KeyPress(VKey key, List <VKey> pressedKeys)
{
Sound sound = ResolveShortcut(key, pressedKeys, _configurationModel.SelectedPreset.SoundCollection.Where(x => x.Files.Count != 0));
if (sound != null)
{
_configurationModel.SelectedPreset.SelectedSound = sound;
_soundManager.Play(sound);
}
Preset preset = ResolveShortcut(key, pressedKeys, _configurationModel.PresetCollection);
if (preset != null)
{
_configurationModel.SelectedPreset = preset;
}
}
public static string GetKeyDescription(VKey key)
{
FieldInfo fi = key.GetType().GetField(key.ToString());
DescriptionAttribute[] attributes =
(DescriptionAttribute[])fi.GetCustomAttributes(
typeof(DescriptionAttribute),
false);
if (attributes != null && attributes.Length > 0)
{
return(attributes[0].Description);
}
else
{
return(key.ToString());
}
}
public static KeyEvent[] ToKeyboardInput(this string input)
{
List <KeyEvent> events = new List <KeyEvent>();
ShiftState pressedState = ShiftState.NONE;
for (int i = 0; i < input.Length; i++)
{
ShiftState newState;
VKey key = GetVirtualKey(input[i], out newState);
if (!newState.Equals(pressedState)) //state is different from current one
{
if (!pressedState.Equals(ShiftState.NONE)) //release all keys
{
events.AddRange(pressedState.ToEvents(false));
}
if (!newState.Equals(ShiftState.NONE)) //press new keys
{
events.AddRange(newState.ToEvents(true));
}
pressedState = newState;
}
KeyEvent down = new KeyEvent {
keycode = key, downpress = true
};
KeyEvent up = new KeyEvent {
keycode = key, downpress = false
};
events.Add(down);
events.Add(up);
}
if (!pressedState.Equals(ShiftState.NONE)) //release last keys
{
events.AddRange(pressedState.ToEvents(false));
}
return(events.ToArray());
}
public static KeyEvent[] ToEvents(this ShiftState shift, bool downpress)
{
List <KeyEvent> events = new List <KeyEvent>();
ShiftState[] flags = new ShiftState[] { ShiftState.ALT, ShiftState.CTRL, ShiftState.HANKAKU, ShiftState.SHIFT };
VKey[] mapto = new VKey[] { VKey.ALT, VKey.CONTROL, VKey.UNDEFINED, VKey.SHIFT };
for (int i = 0; i < flags.Length; i++)
{
if ((shift | flags[i]) > 0)
{
events.Add(new KeyEvent()
{
keycode = mapto[i], downpress = downpress
});
}
}
return(events.ToArray());
}
/// <summary>
/// Determines if a given virtual key is an extended key.
/// </summary>
/// <param name="vKey">Virtual key in question.</param>
/// <returns>true if the virtual key is an extended key, otherwise false.</returns>
public static bool IsExtendedKey(VKey vKey)
{
switch (vKey)
{
case VKey.VK_UP:
case VKey.VK_DOWN:
case VKey.VK_LEFT:
case VKey.VK_RIGHT:
case VKey.VK_HOME:
case VKey.VK_END:
case VKey.VK_PRIOR:
case VKey.VK_NEXT:
case VKey.VK_INSERT:
case VKey.VK_DELETE:
return(true);
default:
return(false);
}
}
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
/// <param name="alt">Simulate alt key.</param>
/// <param name="ctrl">Simulate control key.</param>
/// <param name="shift">Simulate shift key.</param>
/// <param name="winKey">Simulate windows key.</param>
public static void KeyPress(VKey vKey, bool alt, bool ctrl, bool shift, bool winKey)
{
if (alt)
{
KeyDown(VKey.VK_MENU);
}
if (ctrl)
{
KeyDown(VKey.VK_CONTROL);
}
if (shift)
{
KeyDown(VKey.VK_SHIFT);
}
if (winKey)
{
KeyDown(VKey.VK_LWIN);
}
KeyPress(vKey);
if (winKey)
{
KeyUp(VKey.VK_LWIN);
}
if (shift)
{
KeyUp(VKey.VK_SHIFT);
}
if (ctrl)
{
KeyUp(VKey.VK_CONTROL);
}
if (alt)
{
KeyUp(VKey.VK_MENU);
}
}
private void OnKeyPressed(object sender, InputEventArg e)
{
VKey key = (VKey)e.KeyPressEvent.VKey;
if (e.KeyPressEvent.Message == 256 || e.KeyPressEvent.Message == 260)
{
if (!(key == VKey.SHIFT && pressedKeys.Contains(key)))
{
if (shiftNumpadCorrection && numpadKeys.ContainsKey(key))
{
shiftNumpadTimer.Stop();
shiftNumpadCorrection = false;
Key_Down(numpadKeys[key]);
}
else
{
Key_Down(key);
}
}
}
else if (e.KeyPressEvent.Message == 257 || e.KeyPressEvent.Message == 261)
{
if (key == VKey.SHIFT)
{
shiftNumpadTimer.Interval = 5;
shiftNumpadTimer.Start();
shiftNumpadCorrection = true;
}
else if (!pressedKeys.Contains(key) && numpadKeys.ContainsKey(key))
{
Key_Up(numpadKeys[key]);
}
else
{
Key_Up(key);
}
}
}
public void KeyPress(VKey key, List <VKey> pressedKeys)
{
if (_configurationModel.Enable == DisplayOption.Sounds || _configurationModel.Enable == DisplayOption.Both)
{
Sound sound = ResolveShortcut(key, pressedKeys, _configurationModel.SelectedPreset.SoundCollection.Where(x => x.Files.Count != 0));
if (sound != null)
{
_configurationModel.SelectedPreset.SelectedSound = sound;
_soundManager.Play(sound);
}
}
Preset preset = ResolveShortcut(key, pressedKeys, _configurationModel.PresetCollection);
if (preset != null)
{
_configurationModel.SelectedPreset = preset;
foreach (Counter counter in preset.CounterCollection)
{
counter.ReadFromFile();
}
}
}
public static extern short GetKeyState(VKey vkey);
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
/// <param name="alt">Simulate alt key.</param>
/// <param name="ctrl">Simulate control key.</param>
/// <param name="shift">Simulate shift key.</param>
/// <param name="winKey">Simulate windows key.</param>
public static void KeyPress(VKey vKey, bool alt, bool ctrl, bool shift, bool winKey)
{
if (alt) KeyDown(VKey.VK_MENU);
if (ctrl) KeyDown(VKey.VK_CONTROL);
if (shift) KeyDown(VKey.VK_SHIFT);
if (winKey) KeyDown(VKey.VK_LWIN);
KeyPress(vKey);
if (winKey) KeyUp(VKey.VK_LWIN);
if (shift) KeyUp(VKey.VK_SHIFT);
if (ctrl) KeyUp(VKey.VK_CONTROL);
if (alt) KeyUp(VKey.VK_MENU);
}
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
/// <param name="modifiers">Key modifiers in effect.</param>
public static void KeyPress(VKey vKey, byte modifiers)
{
bool alt = Win32.CheckMask(modifiers, (byte) KeyModifiers.Alt);
bool ctrl = Win32.CheckMask(modifiers, (byte) KeyModifiers.Ctrl);
bool shift = Win32.CheckMask(modifiers, (byte) KeyModifiers.Shift);
KeyPress(vKey, alt, ctrl, shift, false);
}
/// <summary>
/// Determines if a given virtual key is an extended key.
/// </summary>
/// <param name="vKey">Virtual key in question.</param>
/// <returns>true if the virtual key is an extended key, otherwise false.</returns>
public static bool IsExtendedKey(VKey vKey)
{
switch (vKey)
{
case VKey.VK_UP:
case VKey.VK_DOWN:
case VKey.VK_LEFT:
case VKey.VK_RIGHT:
case VKey.VK_HOME:
case VKey.VK_END:
case VKey.VK_PRIOR:
case VKey.VK_NEXT:
case VKey.VK_INSERT:
case VKey.VK_DELETE:
return true;
default:
return false;
}
}
/// <summary>
/// Gets the character that maps to the Virtual Key provided.
/// </summary>
/// <param name="vKey">The virtual key.</param>
/// <returns>The character.</returns>
public static char GetCharFromVKey(VKey vKey)
{
return (char)MapVirtualKey((uint)vKey, MAPVK_VK_TO_CHAR);
}
/*
/// <summary>
/// Simulate a key being pressed down.
/// </summary>
/// <param name="vKey">Virtual key to press.</param>
public static void KeyDown(VKey vKey)
{
keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyDown, IntPtr.Zero);
}
/// <summary>
/// Simulate a key being released.
/// </summary>
/// <param name="vKey">Virtual key to release.</param>
public static void KeyUp(VKey vKey)
{
keybd_event((byte)vKey, 0, (uint)KeyEvents.KeyUp, IntPtr.Zero);
}
*/
/// <summary>
/// Simulate a Virtual Key event.
/// </summary>
/// <param name="vKey">Virtual Key.</param>
/// <param name="scan">Scan code.</param>
/// <param name="flags">Event type.</param>
/// <param name="extraInfo">Pointer to additional information.</param>
public static void Event(VKey vKey, byte scan, KeyEvents flags, IntPtr extraInfo)
{
keybd_event((byte)vKey, scan, (uint)flags, extraInfo);
}
/// <summary>
/// Simulate a key being pressed down and immediately released.
/// </summary>
/// <param name="vKey">Virtual key to simulate.</param>
public static void KeyPress(VKey vKey)
{
bool isExtended = IsExtendedKey(vKey);
uint scanCode = MapVirtualKey((uint) vKey, 0);
if (isExtended)
{
keybd_event((byte) vKey, (byte) scanCode, (uint) KeyEvents.KeyDown | (uint) KeyEvents.ExtendedKey, IntPtr.Zero);
keybd_event((byte) vKey, (byte) scanCode, (uint) KeyEvents.KeyUp | (uint) KeyEvents.ExtendedKey, IntPtr.Zero);
}
else
{
keybd_event((byte) vKey, (byte) scanCode, (uint) KeyEvents.KeyDown, IntPtr.Zero);
keybd_event((byte) vKey, (byte) scanCode, (uint) KeyEvents.KeyUp, IntPtr.Zero);
}
}
public static extern short GetKeyState(VKey nVirtKey);
