public static void ShellKeyCombo(VirtualKeyShort vK1, VirtualKeyShort vK2)
{
INPUT[] inputs = new INPUT[4];
inputs[0].type = INPUT_KEYBOARD;
inputs[0].U.ki.time = 0;
inputs[0].U.ki.wScan = 0;
inputs[0].U.ki.dwExtraInfo = GetMessageExtraInfo();
inputs[0].U.ki.wVk = vK1;
inputs[0].U.ki.dwFlags = 0;
inputs[1].type = INPUT_KEYBOARD;
inputs[1].U.ki.wScan = 0;
inputs[1].U.ki.dwExtraInfo = GetMessageExtraInfo();
inputs[1].U.ki.wVk = vK2;
inputs[1].U.ki.dwFlags = 0;
inputs[2].type = INPUT_KEYBOARD;
inputs[2].U.ki.wScan = 0;
inputs[2].U.ki.dwExtraInfo = GetMessageExtraInfo();
inputs[2].U.ki.wVk = vK2;
inputs[2].U.ki.dwFlags = KEYEVENTF.KEYUP;
inputs[3].type = INPUT_KEYBOARD;
inputs[3].U.ki.wScan = 0;
inputs[3].U.ki.dwExtraInfo = GetMessageExtraInfo();
inputs[3].U.ki.wVk = vK1;
inputs[3].U.ki.dwFlags = KEYEVENTF.KEYUP;
SendInput(4, inputs, Marshal.SizeOf(typeof(INPUT)));
}
public Module(Cheat cheat, VirtualKeyShort bind, string name)
{
Cheat = cheat;
Bind = bind;
Name = name;
IsToggled = false;
}
public void Send(ScanCodeShort key, float downTime = KEY_DOWN_TIME, Action callback = null)
{
if (WinUtils.GetActiveWindow() != this.window)
{
Stop();
return;
}
else if (IsKeyDownTimerActive(key))
{
return;
}
downTime = Math.Max(KEY_DOWN_TIME, downTime);
Timer timer = TryGetTimerForKey(key);
if (timer != null)
{
timer.Stop();
timer.Interval = downTime * 1000;
keydownTimers[key] = new Tuple <Timer, Action>(timer, callback);
VirtualKeyShort vk = GetVK(key);
SendInput(vk, key, KEYEVENTF.SCANCODE);
timer.Start();
}
}
public TFKey(VirtualKeyShort VirtualKeyShort, ScanCodeShort ScanCodeShort, String TFKeyName, String DisplayText)
{
this.VirtualKeyShort = VirtualKeyShort;
this.ScanCodeShort = ScanCodeShort;
this.TFKeyName = TFKeyName;
this.DisplayText = DisplayText;
}
/// <summary>
/// Presses a key.
/// </summary>
/// <param name="key">Virtual Key Short</param>
/// <param name="sendToSystem">Set if key message (or a combination of such) cannot be correctly interpreted by the game client.</param>
public static void Press(VirtualKeyShort key, bool sendToSystem = false)
{
if (!GameService.GameIntegration.Gw2IsRunning || sendToSystem)
{
var nInputs = new[]
{
new Extern.Input
{
type = InputType.KEYBOARD,
U = new InputUnion
{
ki = new KeybdInput
{
wScan = (ScanCodeShort)PInvoke.MapVirtualKey((uint)key, MAPVK_VK_TO_VSC),
wVk = key
}
}
}
};
PInvoke.SendInput((uint)nInputs.Length, nInputs, Extern.Input.Size);
}
else
{
uint vkCode = (uint)key;
ExtraKeyInfo lParam = new ExtraKeyInfo()
{
scanCode = (char)PInvoke.MapVirtualKey(vkCode, MAPVK_VK_TO_VSC)
};
PInvoke.PostMessage(GameService.GameIntegration.Gw2WindowHandle, WM_KEYDOWN, vkCode, lParam.GetInt());
}
}
/// <summary>
/// Releases a key.
/// </summary>
/// <param name="key">Virtual Key Short</param>
/// <param name="sendToSystem">Set if key message (or a combination of such) cannot be correctly interpreted by the game client.</param>
public static void Release(VirtualKeyShort key, bool sendToSystem = false)
{
if (!GameService.GameIntegration.Gw2IsRunning || sendToSystem)
{
var nInputs = new[]
{
new Extern.Input
{
type = InputType.KEYBOARD,
U = new InputUnion
{
ki = new KeybdInput
{
wScan = (ScanCodeShort)PInvoke.MapVirtualKey((uint)key, MAPVK_VK_TO_VSC),
wVk = key,
dwFlags = KeyEventF.KEYUP
}
}
}
};
PInvoke.SendInput((uint)nInputs.Length, nInputs, Extern.Input.Size);
}
else
{
uint vkCode = (uint)key;
ExtraKeyInfo lParam = new ExtraKeyInfo
{
scanCode = (char)PInvoke.MapVirtualKey(vkCode, MAPVK_VK_TO_VSC),
repeatCount = 1,
prevKeyState = 1,
transitionState = 1
};
PInvoke.PostMessage(GameService.GameIntegration.Gw2WindowHandle, WM_KEYUP, vkCode, lParam.GetInt());
}
}
delegate void UsefulDelegate(); //used to change labels
public ServerPanel(int index, Host h)
{
i = index; // index of the server
_host = h; // host global object
c_flag = false;
switch (i)
{
case 0:
hk = VirtualKeyShort.KEY_1;
break;
case 1:
hk = VirtualKeyShort.KEY_2;
break;
case 2:
hk = VirtualKeyShort.KEY_3;
break;
case 3:
hk = VirtualKeyShort.KEY_4;
break;
}
this.InitializeComponent();
}
public short KeyState(ScanCodeShort key)
{
int keycode = (int)key;
VirtualKeyShort keyShort = GetVK(key);
keycode = (int)(keyShort);
return(GetKeyState(keycode));
}
public KeyboardCommand createVirtualKey(VirtualKeyShort vk, bool keyDown = true)
{
var res = new KeyboardCommand();
res.keyType = KeyType.VIRTUAL_KEY;
res.vk = vk;
res.keyDown = keyDown;
return(res);
}
public static short getVirtualKeyShortByName(string name)
{
//получаю значение enum по имени
VirtualKeyShort elem = (VirtualKeyShort)Enum.Parse(typeof(VirtualKeyShort), name);
//return elem;
object val = Convert.ChangeType(elem, elem.GetTypeCode());
return((short)val);
}
public void SendVirtual(VirtualKeyShort v)
{
ScanCodeShort a = GetScanFromVirtual(v);
if (a != ScanCodeShort.LBUTTON)
{
Send(a);
}
}
/// <summary>
/// Simulates a key press via User32.dll=>SendInput
/// </summary>
/// <param name="key">The key to send.</param>
public static IEnumerator simulateKeyPressCoroutine(VirtualKeyShort wVk)
{
// Written, 08.10.2020
send(wVk, KeyEventF.KEYDOWN);
yield return(new WaitForSeconds(0.3f));
send(wVk, KeyEventF.KEYUP);
}
private void kbh_OnKeyPressed(object sender, VirtualKeyShort e)
{
if (e == VirtualKeyShort.VOLUME_UP || e == VirtualKeyShort.VOLUME_DOWN ||
e == VirtualKeyShort.VOLUME_MUTE ||
e == VirtualKeyShort.MEDIA_NEXT_TRACK || e == VirtualKeyShort.MEDIA_PREV_TRACK ||
e == VirtualKeyShort.MEDIA_PLAY_PAUSE || e == VirtualKeyShort.MEDIA_STOP)
{
VolumeSMTC.FindSMTCAndHide(); //Is this CPU expensive?
w.Show();
}
}
public void Send(VirtualKeyShort a)
{
INPUT[] Inputs = new INPUT[1];
INPUT Input = new INPUT();
Input.type = 1; // 1 = Keyboard Input
Input.U.ki.wVk = a;
Input.U.ki.dwFlags = KEYEVENTF.UNICODE;
Inputs[0] = Input;
SendInput(1, Inputs, INPUT.Size);
}
public static void PressKey(VirtualKeyShort key)
{
const int KEYEVENTF_EXTENDEDKEY = 0; // 0x1;
const int KEYEVENTF_KEYUP = 0x2;
const int EXTRA = 0x4;
UnhookWindowsHookEx(_hookID);
keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY | EXTRA, (UIntPtr)0);
keybd_event((byte)key, 0x45, KEYEVENTF_EXTENDEDKEY | EXTRA | KEYEVENTF_KEYUP, (UIntPtr)0);
_hookID = SetHook(_proc);
}
// Written, 08.10.2020
/// <summary>
/// Sends the provided key.
/// </summary>
/// <param name="key">The key to send</param>
private static void send(VirtualKeyShort wVk, KeyEventF eventF)
{
// Written, 06.10.2020
Input[] inputs = new Input[1];
inputs[0].type = 1; // 1 = Keyboard Input
inputs[0].U = createKeyEvent(wVk, eventF, 0, UIntPtr.Zero);
if (NativeMethods.SendInput((uint)inputs.Length, inputs, Input.Size) == 0)
{
MoControlsMod.print(string.Format("Error: {0}", new Win32Exception(Marshal.GetLastWin32Error()).Message), Debugging.DebugTypeEnum.full);
}
}
public void SendUp(ScanCodeShort key)
{
if (IsKeyDownTimerActive(key))
{
Debug.Log("This key is already being pressed");
return;
}
VirtualKeyShort code = GetVK(key);
SendInput(code, key, KEYEVENTF.KEYUP);
}
/* switch callback */
public static IntPtr KswitchCB(int nCode, IntPtr wParam, IntPtr LParam)
{
unsafe
{
_nVKS = (VirtualKeyShort)((KBDLLHOOKSTRUCT *)LParam.ToPointer())->vkCode;
}
WindowsAPI.UnhookWindowsHookEx(KEYhook);
WindowsAPI.UnhookWindowsHookEx(MOUSEhook);
return(new IntPtr(1));
}
static void SendKey(VirtualKeyShort vk, bool isDown)
{
var InputData = new INPUT[1];
InputData[0].type = 1;
InputData[0].U.ki.wVk = vk;
InputData[0].U.ki.wScan = (ScanCodeShort)MapVirtualKey((uint)vk, MAPVK_VK_TO_VSC);
//InputData[0].U.ki.dwFlags = (isScanCode ? KEYEVENTF.SCANCODE : 0) | KEYEVENTF.KEYUP;
InputData[0].U.ki.dwFlags = (isDown ? 0 : KEYEVENTF.KEYUP) | KEYEVENTF.SCANCODE;
InputData[0].U.ki.time = 0;
InputData[0].U.ki.dwExtraInfo = UIntPtr.Zero;
var r = SendInput(1, InputData, Marshal.SizeOf(typeof(INPUT)));
}
private void AddInput(VirtualKeyShort vk, ScanCodeShort sc)
{
INPUT tmp = new INPUT();
tmp.type = EINPUT.KEYBOARD;
tmp.U.ki.wVk = vk;
tmp.U.ki.wScan = sc;
tmp.U.ki.time = 0;
tmp.U.ki.dwFlags = KEYEVENTF.UNICODE;
tmp.U.ki.dwExtraInfo = UIntPtr.Zero;
m_input.Add(tmp);
tmp.U.ki.dwFlags |= KEYEVENTF.KEYUP;
m_input.Add(tmp);
}
private void Add(VirtualKeyShort vk, ScanCodeShort sc)
{
INPUT tmp = new INPUT();
tmp.type = EINPUT.KEYBOARD;
tmp.U.ki.wVk = vk;
tmp.U.ki.wScan = sc;
tmp.U.ki.time = 0;
tmp.U.ki.dwFlags = KEYEVENTF.UNICODE;
tmp.U.ki.dwExtraInfo = UIntPtr.Zero;
m_input.Add(tmp);
tmp.U.ki.dwFlags |= KEYEVENTF.KEYUP;
m_input.Add(tmp);
}
static INPUT GenerateKeystoke(VirtualKeyShort key, KEYEVENTF flags = 0)
{
return(new INPUT
{
type = 1,
U = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = key,
dwFlags = flags,
wScan = 0
}
}
});
}
public static void SendKeyToWindow(IntPtr Window, VirtualKeyShort Key, bool Up, bool Recursive = false)
{
if (!PostMessage(Window, Up ? WM.KEYUP : WM.KEYDOWN, (uint)Key, 0))
{
throw new Win32Exception();
}
if (Recursive)
{
EnumChildWindows(Window, (IntPtr hwnd, IntPtr param) =>
{
SendKeyToWindow(hwnd, Key, Up, false);
return(true);
}, IntPtr.Zero);
}
}
static INPUT GenerateKeystoke(VirtualKeyShort key, KEYEVENTF flags = 0)
{
return new INPUT()
{
type = 1,
U = new InputUnion()
{
ki = new KEYBDINPUT()
{
wVk = key,
dwFlags = flags,
wScan = 0
}
}
};
}
public static void SendKey(ScanCodeShort sc, VirtualKeyShort vk, bool up = false)
{
var inp = new INPUT();
inp.Type = InputType.KEYBOARD;
inp.Input.ki.dwFlags = up ? KeyEventFlags.KEYUP : 0;
inp.Input.ki.wVk = vk;
inp.Input.ki.wScan = sc;
inp.Input.ki.time = 0;
inp.Input.ki.dwExtraInfo = IntPtr.Zero;
if (SendInput(1, ref inp, INPUT.Size) != 1)
{
throw new Win32Exception();
}
}
public void SendDown(ScanCodeShort key)
{
if (WinUtils.GetActiveWindow() != this.window)
{
Stop();
return;
}
else if (IsKeyDownTimerActive(key))
{
Debug.Log("This key is already being pressed");
return;
}
VirtualKeyShort code = GetVK(key);
SendInput(code, key);
}
/// <summary>
/// Creates a key event wrapped in a inputUnion structure. Passed to: <see cref="NativeMethods.SendInput(uint, Input[], int)"/>
/// </summary>
/// <param name="wScan">The scan keycode</param>
/// <param name="dwFlags">dword flags</param>
/// <param name="time">the time?</param>
/// <param name="dwExtraInfo">dword extra info</param>
/// <returns></returns>
private static InputUnion createKeyEvent(VirtualKeyShort wVk, KeyEventF dwFlags, int time, UIntPtr dwExtraInfo)
{
// Written, 08.10.2020
InputUnion result = new InputUnion
{
ki = new KeyboardInput()
{
dwExtraInfo = dwExtraInfo,
dwFlags = dwFlags,
time = time,
wVk = wVk,
}
};
return(result);
}
public static Input GetKeyboardInput(ScanCodeShort keyScanCodeShort, VirtualKeyShort virtualKeyShort,
KeyEventF keyEventF)
{
return(new Input()
{
type = InputType.KEYBOARD,
U = new InputUnion()
{
ki = new KEYBDINPUT()
{
wScan = keyScanCodeShort,
wVk = virtualKeyShort,
dwFlags = keyEventF
}
}
});
}
public static void SendI(VirtualKeyShort k, ScanCodeShort kN)
{
INPUT[] inputs = new INPUT[1];
inputs[0] = new INPUT()
{
type = InputType.KEYBOARD,
U = new InputUnion
{
ki = new KEYBDINPUT
{
wVk = k,
wScan = kN,
}
}
};
ActivateApp("EmuHawk");
SendInput((uint)1, inputs, INPUT.Size);
}
private void SendInput(VirtualKeyShort key, ScanCodeShort scanCode, KEYEVENTF?flag = null)
{
INPUT[] Inputs = new INPUT[1];
INPUT Input = new INPUT();
Input.type = 1; // 1 = Keyboard Input
Input.U.ki.wScan = scanCode;
Input.U.ki.wVk = key;
Input.U.ki.dwFlags = 0;
if (flag.HasValue)
{
Input.U.ki.dwFlags = flag.Value;
}
Input.U.ki.time = 0;
Input.U.ki.dwExtraInfo = UIntPtr.Zero;
Inputs[0] = Input;
uint nb = SendInput(1, Inputs, INPUT.Size);
}
VirtualKeyShort GetVK(ScanCodeShort scanCode)
{
if (!scanCodeMap.ContainsKey(scanCode))
{
uint code = (uint)scanCode;
uint result = MapVirtualKeyA(code, (uint)MAPTYPE.MAPVK_VSC_TO_VK);
if (result != 0)
{
VirtualKeyShort keyShort = (VirtualKeyShort)result;
scanCodeMap[scanCode] = keyShort;
}
else
{
throw new Exception($"Failed to Map ScanCodeShort: {scanCode} to VirtualKeyShort");
}
}
return(scanCodeMap[scanCode]);
}
public static void SendKeyDown(VirtualKeyShort key)
{
var union = new InputUnion()
{
ki = new KEYBDINPUT()
{
wVk = key,
wScan = 0,
time = 0,
dwExtraInfo = GetMessageExtraInfo()
}
};
var input = new INPUT()
{
type = InputType.KEYBOARD, U = union
};
SendInput(1, new INPUT[] { input }, INPUT.Size);
}
public void ReleaseKey(VirtualKeyShort keyCode) => PressOrReleaseKey(keyCode, false);
public void AddInput(VirtualKeyShort vk)
{
AddInput(vk, (ScanCodeShort)0);
}
public static void SendForgroundKey(ScanCodeShort wScan, VirtualKeyShort wVk, int holdTimeout)
{
INPUT[] pInputs = new INPUT[1];
pInputs[0].type = 1;
pInputs[0].U.ki.wScan = wScan;
pInputs[0].U.ki.wVk = wVk;
User32.SendInput((uint)pInputs.Length,pInputs,INPUT.Size);
System.Threading.Thread.Sleep(holdTimeout);
pInputs[0].U.ki.dwFlags = KEYEVENTF.KEYUP;
User32.SendInput((uint)pInputs.Length,pInputs,INPUT.Size);
}
public static extern short GetAsyncKeyState(VirtualKeyShort vKey);
public static void SendForgroundKeyUp(ScanCodeShort wScan,VirtualKeyShort wVk)
{
INPUT[] pInputs = new INPUT[1];
pInputs[0].type = 1;
pInputs[0].U.ki.wScan = wScan;
pInputs[0].U.ki.wVk = wVk;
pInputs[0].U.ki.dwFlags = KEYEVENTF.KEYUP;
User32.SendInput((uint)pInputs.Length,pInputs,INPUT.Size);
}
static extern short GetKeyState(VirtualKeyShort nVirtKey);
private static INPUT NewInputKey(VirtualKeyShort vk)
{
INPUT ret = NewInputKey();
ret.U.ki.wVk = vk;
return ret;
}
public void PressKey(VirtualKeyShort keyCode) => PressOrReleaseKey(keyCode, true);
private void Text_Changed(object sender, TextChangedEventArgs e)
{
TextBox textBox = sender as TextBox;
string text = textBox.Text;
if (!string.IsNullOrEmpty(text))
{
// Convert character to Virtual Key Hex
char[] chars = text.ToCharArray();
short s = NativeMethods.VkKeyScan(chars[0]);
currentKey = (VirtualKeyShort)s;
}
}
private void PressOrReleaseKey(VirtualKeyShort keyCode, bool down)
{
var ki = new NativeMethods.KEYBDINPUT();
ki.wVk = keyCode;
if (!down)
ki.dwFlags = NativeMethods.KEYEVENTF.KEYUP;
var input = new NativeMethods.INPUT();
input.type = NativeMethods.INPUT_KEYBOARD;
input.U.ki = ki;
NativeMethods.INPUT[] inputs = { input };
if (NativeMethods.SendInput((uint)inputs.Length, inputs, NativeMethods.INPUT.Size) == 0)
throw new Win32Exception();
}
static void SendKey(VirtualKeyShort vk, bool isDown)
{
var InputData = new INPUT[1];
InputData[0].type = 1;
InputData[0].U.ki.wVk = vk;
InputData[0].U.ki.wScan = (ScanCodeShort)MapVirtualKey((uint)vk, MAPVK_VK_TO_VSC);
//InputData[0].U.ki.dwFlags = (isScanCode ? KEYEVENTF.SCANCODE : 0) | KEYEVENTF.KEYUP;
InputData[0].U.ki.dwFlags = (isDown ? 0 : KEYEVENTF.KEYUP) | KEYEVENTF.SCANCODE;
InputData[0].U.ki.time = 0;
InputData[0].U.ki.dwExtraInfo = UIntPtr.Zero;
var r = SendInput(1, InputData, Marshal.SizeOf(typeof(INPUT)));
}
