/// <summary>
/// Function to update the keyboard label.
/// </summary>
/// <param name="key">Key that's currently pressed.</param>
/// <param name="shift">Shifted keys.</param>
private void UpdateKeyboardLabel(KeyboardKeys key, KeyboardKeys shift)
{
var shiftKey = KeyboardKeys.None;
if ((KeyboardKeys.Alt & shift) == KeyboardKeys.Alt)
{
shiftKey = (shift & KeyboardKeys.LeftVersion) == KeyboardKeys.LeftVersion ? KeyboardKeys.LMenu : KeyboardKeys.RMenu;
}
if ((shift & KeyboardKeys.Control) == KeyboardKeys.Control)
{
shiftKey = (shift & KeyboardKeys.LeftVersion) == KeyboardKeys.LeftVersion ? KeyboardKeys.LControlKey : KeyboardKeys.RControlKey;
}
if ((shift & KeyboardKeys.Shift) == KeyboardKeys.Shift)
{
shiftKey = (shift & KeyboardKeys.LeftVersion) == KeyboardKeys.LeftVersion ? KeyboardKeys.LShiftKey : KeyboardKeys.RShiftKey;
}
labelKeyboard.Text = string.Format("{2}. Currently pressed key: {0}{1} (Press 'P' to switch between polling and events for the mouse. Press 'ESC' to close.)"
, key
, ((shiftKey != KeyboardKeys.None) && (shiftKey != key) ? " + " + shiftKey : string.Empty)
, _keyboard.Name);
}
protected void HandleKeyPress(KeyCode keyCode)
{
var key = KeyboardKeys
.Where(o =>
!o.HasBeenActivated &&
o.Image.rectTransform.anchoredPosition.x >= -80 &&
o.Image.rectTransform.anchoredPosition.x <= 80)
.OrderBy(o => o.Image.rectTransform.anchoredPosition.x)
.FirstOrDefault();
if (key == null)
{
BadKeyPresses++;
return;
}
if (key.KeyCode != keyCode)
{
BadKeyPresses++;
return;
}
if (key.Image.rectTransform.anchoredPosition.x <= 100)
{
ActivateButton(key, true);
}
}
public KeyboardControl()
{
InitializeComponent();
// Add keyboard keys to listBox
string[] keyboardKeys = Enum.GetNames(typeof(KeyboardKeys));
keysListBox.Items.Insert(0, "Select a Key");
keysListBox.Text = "Select a Key";
keysListBox.Items.AddRange(keyboardKeys);
keysListBox.SelectedIndexChanged += KeysListBox_SelectedIndexChanged;
// Add an event button handler to every button inside the keyboard panel
List <Button> keyboardButtons = keyboardPanel.Controls.OfType <Button>().Where(b => b.Enabled).ToList();
foreach (Button button in keyboardButtons)
{
string enumName = button.Name.Substring(0, button.Name.IndexOf("Button")); // Remove "button" from name
KeyboardKeys key = (KeyboardKeys)Enum.Parse(typeof(KeyboardKeys), enumName, true);
button.Click += (object sender, EventArgs e) =>
{
// OnClickHandler
UpdateKey(key);
};
}
}
public KeyboardPressMacro(string macroName, string note, KeyboardKeys kbdKey) : base(macroName, note)
{
Key = kbdKey;
string enumName = Enum.GetName(typeof(Keys), (int)kbdKey);
_kbdKey = (Keys)Enum.Parse(typeof(Keys), enumName, true);
}
protected void CheckForOver()
{
if (!KeyboardKeys
.Any(o => !o.HasBeenActivated))
{
IsCheckingForOver = false;
// TODO - CHANGE FOR TESTING
DoAfter(1, () =>
{
int totalKeyPresses = GoodKeyPresses + BadKeyPresses;
bool wasSuccessful = (float)GoodKeyPresses / (float)totalKeyPresses >= 0.75f;
RoundOverPanel
.Open(wasSuccessful, GoodKeyPresses, totalKeyPresses);
if (wasSuccessful)
{
DoAfter(3, () =>
{
RoundOverPanel
.Close();
LevelManager
.AdvanceLevel();
});
}
});
//LevelManager
// .AdvanceLevel();
}
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
// Up
if (key == KeyboardKeys.ArrowUp)
{
int index = IndexInParent - 1;
if (index >= 0)
{
var target = Parent.GetChild(index);
target.Focus();
((Panel)Parent.Parent).ScrollViewTo(target);
return(true);
}
}
// Down
else if (key == KeyboardKeys.ArrowDown)
{
int index = IndexInParent + 1;
if (index < Parent.ChildrenCount)
{
var target = Parent.GetChild(index);
target.Focus();
((Panel)Parent.Parent).ScrollViewTo(target);
return(true);
}
}
// Ctrl+C
else if (key == KeyboardKeys.C && Root.GetKey(KeyboardKeys.Control))
{
Copy();
return(true);
}
return(base.OnKeyDown(key));
}
private void OnUpdate(object sender, UpdateEventArgs e)
{
if (Input.anyKeyDown || Time.time - lastKeyPressTime > KeyPressDelay)
{
lastKeyPressTime = Time.time;
if (TargetingSystem.IsPlayerTargeting)
{
KeyboardKeys key = screen.GetUserKey();
if (TargetingSystem.HandleKey(key))
{
CommandSystem.EndPlayerTurn();
}
needRender = true;
}
else if (CommandSystem.IsPlayerTurn)
{
CheckKeyboard();
}
else
{
CommandSystem.ActivateEnemies();
needRender = true;
}
}
Logger.Draw();
if (needRender)
{
Draw();
needRender = false;
}
}
public DigitalButton Assign(KeyboardKeys key)
{
// Should it replace the assignment?
this.mappingKeys.Add(key);
return this;
}
void SendKeyKeyboard(KeyboardKeys sendKey)
{
try
{
//Check if the caps lock is enabled
if (vCapsEnabled)
{
if (sendKey == KeyboardKeys.Enter)
{
vFakerInputDevice.KeyboardPressRelease(KeyboardModifiers.ControlLeft, KeyboardModifiers.None, KeyboardKeys.Z, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None);
}
else if (sendKey == KeyboardKeys.Home)
{
vFakerInputDevice.KeyboardPressRelease(KeyboardModifiers.None, KeyboardModifiers.None, KeyboardKeys.Home, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None);
}
else if (sendKey == KeyboardKeys.End)
{
vFakerInputDevice.KeyboardPressRelease(KeyboardModifiers.None, KeyboardModifiers.None, KeyboardKeys.End, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None);
}
else
{
vFakerInputDevice.KeyboardPressRelease(KeyboardModifiers.ShiftLeft, KeyboardModifiers.None, sendKey, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None);
}
}
else
{
vFakerInputDevice.KeyboardPressRelease(KeyboardModifiers.None, KeyboardModifiers.None, sendKey, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None, KeyboardKeys.None);
}
}
catch { }
}
internal MenuItem FindHotKey(MenuItem P, KeyboardKeys KeyCode)
{
MenuItem T;
while (P != null)
{
if (P.Name != "")
{
if (P.Command == 0)
{
T = FindHotKey(P.SubMenu.Items, KeyCode);
if (T != null)
{
return(T);
}
}
else
if ((!P.Disabled) && (P.KeyCode != KeyboardKeys.NoKey) && (P.KeyCode == KeyCode))
{
return(P);
}
}
P = P.Next;
}
return(null);
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
if (IsFocused)
{
switch (key)
{
case KeyboardKeys.F2:
StartRenaming();
return(true);
case KeyboardKeys.Delete:
Editor.Instance.Windows.ContentWin.Delete(Folder);
return(true);
}
if (RootWindow.GetKey(KeyboardKeys.Control))
{
switch (key)
{
case KeyboardKeys.D:
Editor.Instance.Windows.ContentWin.Duplicate(Folder);
return(true);
}
}
}
return(base.OnKeyDown(key));
}
private void HandleKeyPress(KeyboardKeys key)
{
//TODO: Messy, make more readable.
//Check for any KeyWasPressed events
//Then check if Cancel was set to true
//Useful for sub-classes with special input checkers
if (CancelCharacterInput != null)
{
KeyPressed kp = new KeyPressed();
kp.Key = key;
kp.Cancel = false;
CancelCharacterInput(this, kp);
if (kp.Cancel)
{
return;
}
}
StringBuilder sb = new StringBuilder();
sb.Append(Text.Substring(0, _cursorPosition));
sb.Append(key);
sb.Append(Text.Substring(_cursorPosition));
_cursorPosition += 1;
Text = sb.ToString();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="key">Key that is pressed.</param>
/// <param name="modifierKey">Keys that are held down during the event.</param>
/// <param name="character">Character that the key represents.</param>
/// <param name="scanData">Scan code data.</param>
public KeyboardEventArgs(KeyboardKeys key, KeyboardKeys modifierKey, GorgonKeyboard.KeyCharMap character, int scanData)
{
_key = key;
_modifierKey = modifierKey;
_character = character;
_scan = scanData;
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
if (base.OnKeyDown(key))
{
return(true);
}
switch (key)
{
case KeyboardKeys.Return:
if (Root?.FocusedControl != null)
{
Root.SubmitFocused();
}
else
{
OnSubmit();
}
return(true);
case KeyboardKeys.Escape:
OnCancel();
return(true);
case KeyboardKeys.Tab:
Root?.Navigate(NavDirection.Next);
return(true);
}
return(false);
}
protected private void Reset()
{
foreach (var keyboardKey in KeyboardKeys)
{
if (keyboardKey == null || keyboardKey.gameObject == null)
{
continue;
}
#if UNITY_EDITOR
DestroyImmediate(keyboardKey.gameObject);
#else
Destroy(keyboardKey.gameObject);
#endif
}
KeyboardKeys
.Clear();
IsCheckingForOver = false;
SpawnX = 1200;
SpawnTimer = 0;
BadKeyPresses = 0;
GoodKeyPresses = 0;
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
if (base.OnKeyDown(key))
{
return(true);
}
switch (key)
{
case KeyboardKeys.Return:
if (CanUseNavigation && Root?.FocusedControl != null)
{
Root.SubmitFocused();
return(true);
}
break;
case KeyboardKeys.Tab:
if (CanUseNavigation && Root != null)
{
Root.Navigate(NavDirection.Next);
return(true);
}
break;
}
return(false);
}
private void HandlePositionTargeting(KeyboardKeys key)
{
int x = cursorPosition.X;
int y = cursorPosition.Y;
Map map = game.MapManager.Map;
Player player = game.Player;
if (key == KeyboardKeys.Right)
{
x++;
}
else if (key == KeyboardKeys.Left)
{
x--;
}
else if (key == KeyboardKeys.Down)
{
y--;
}
else if (key == KeyboardKeys.Up)
{
y++;
}
if (map.IsInFov(x, y))
{
cursorPosition.X = x;
cursorPosition.Y = y;
}
}
//Send the clicked button
async Task KeyButtonClick(object sender)
{
try
{
PlayInterfaceSound(vConfigurationCtrlUI, "Click", false, false);
Button sendButton = sender as Button;
Type sendKeyType = sendButton.Tag.GetType();
string sendKeyName = sendButton.Tag.ToString();
if (sendKeyType == typeof(string))
{
if (sendKeyName == "EmojiPopup")
{
await ShowHideEmojiListPopup();
}
else if (sendKeyName == "TextListPopup")
{
await ShowHideTextListPopup();
}
}
else
{
if (sendKeyType == typeof(KeyboardKeys))
{
KeyboardKeys sendKey = (KeyboardKeys)sendButton.Tag;
Debug.WriteLine("Sending Keyboard key: " + sendKey);
SendKeyKeyboard(sendKey);
}
else if (sendKeyType == typeof(KeyboardModifiers))
{
KeyboardModifiers sendKey = (KeyboardModifiers)sendButton.Tag;
Debug.WriteLine("Sending Modifier key: " + sendKey);
SendKeyModifier(sendKey);
}
else if (sendKeyType == typeof(KeyboardMultimedia))
{
KeyboardMultimedia sendKey = (KeyboardMultimedia)sendButton.Tag;
Debug.WriteLine("Sending Multimedia key: " + sendKey);
if (sendKey == KeyboardMultimedia.VolumeMute)
{
await VolumeOutputMute();
}
else if (sendKey == KeyboardMultimedia.VolumeUp)
{
await VolumeUp();
}
else if (sendKey == KeyboardMultimedia.VolumeDown)
{
await VolumeDown();
}
else
{
SendKeyMultimedia(sendKey);
}
}
}
}
catch { }
}
public void RegisterReleasedCommand(KeyboardKeys name, Keys key, ICommand command)
{
if (!releasedKeyDict.ContainsKey(name) && !releasedCommandDict.ContainsKey(key))
{
releasedKeyDict.Add(name, key);
releasedCommandDict.Add(key, command);
}
}
public void RegisterCommand(KeyboardKeys name, Keys key, ICommand command)
{
if (!keyDict.ContainsKey(name) && !commandDict.ContainsKey(key))
{
keyDict.Add(name, key);
commandDict.Add(key, command);
}
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents the key enum (for UI).
/// </summary>
/// <param name="key">The key.</param>
/// <returns>A <see cref="System.String" /> that represents the key.</returns>
public static string ToString(KeyboardKeys key)
{
switch (key)
{
case KeyboardKeys.Control: return("Ctrl");
default: return(key.ToString());
}
}
//Update key press byte array
void UpdateKeyPressByteArray(ref byte[] keyArray, ref int keyIndex, KeyboardKeys key)
{
try
{
keyArray[keyIndex] = (byte)key;
keyIndex++;
}
catch { }
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
if (key == KeyboardKeys.Escape)
{
Hide();
return(true);
}
return(base.OnKeyDown(key));
}
public void KeyPressCombo(KeyboardModifiers keyMod, KeyboardKeys keyPress)
{
try
{
KeysPress((byte)keyMod, (byte)keyPress, 0, 0, 0, 0, 0);
Thread.Sleep(50);
KeysRelease();
}
catch { }
}
public static StatusItem NewStatusKey(string text, KeyboardKeys keyCode, int command, StatusItem next)
{
return(new StatusItem()
{
Text = text,
KeyCode = keyCode,
Command = command,
Next = next
});
}
public void KeyPressSingle(KeyboardKeys keyPress)
{
try
{
KeysPress(0, (byte)keyPress, 0, 0, 0, 0, 0);
Thread.Sleep(50);
KeysRelease();
}
catch { }
}
/// <summary>
/// Parses the specified key text value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="result">The result (valid only if parsing succeed).</param>
/// <returns>True if parsing succeed, otherwise false.</returns>
public static bool Parse(string value, out KeyboardKeys result)
{
if (string.Equals(value, "Ctrl", StringComparison.OrdinalIgnoreCase))
{
result = KeyboardKeys.Control;
return(true);
}
return(Enum.TryParse(value, true, out result));
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
// Base
if (base.OnKeyDown(key))
{
return(true);
}
// Custom input events
return(InputActions.Process(Editor, this, key));
}
public bool Clicked(KeyboardKeys input)
{
bool flag = false;
if (currentState.IsKeyUp(KeyBindings[input]) && !previousState.IsKeyUp(KeyBindings[input]))
{
flag = true;
}
//if (previousState.GetPressedKeys().Length > 1) flag = false;
return(flag);
}
/// <inheritdoc />
public override void OnKeyUp(KeyboardKeys key)
{
for (int i = 0; i < _children.Count && _children.Count > 0; i++)
{
var child = _children[i];
if (child.Enabled && child.ContainsFocus)
{
child.OnKeyUp(key);
break;
}
}
}
/// <inheritdoc />
public override bool OnKeyDown(KeyboardKeys key)
{
for (int i = 0; i < _children.Count && _children.Count > 0; i++)
{
var child = _children[i];
if (child.Enabled && child.ContainsFocus)
{
return(child.OnKeyDown(key));
}
}
return(false);
}
/// <summary>
/// Post a key event to a window and return immediately
/// </summary>
/// <param name="windowHandle">The target window</param>
/// <param name="key">Key to send</param>
/// <param name="modifiers">Any modifier keys sent at the same time</param>
/// <param name="pressed">Whether the key is pressed or released</param>
/// <returns>True if successful</returns>
public static bool PostKeyClick(IntPtr windowHandle, KeyboardKeys key, ModifierKeys modifiers, bool pressed)
{
uint msg = GetKeypressWM(pressed);
// lParam is always 0 for button press/released
IntPtr lParam = IntPtr.Zero;
// If the key is pressed, press the modifier first
if (pressed)
{
PostModifierKeys(windowHandle, modifiers, msg, lParam);
}
bool rc = PostMessage(windowHandle, msg, VirtualKeyFromKey(key), lParam);
// If the key is released, release the modifier last
if (!pressed)
{
PostModifierKeys(windowHandle, modifiers, msg, lParam);
}
return rc;
}
/// <summary>
/// Send a key event and wait for the window queue to process the message
/// </summary>
/// <param name="windowHandle">The target window</param>
/// <param name="key">Key to send</param>
/// <param name="modifiers">Any modifier keys sent at the same time</param>
/// <param name="pressed">Whether the key is pressed or released</param>
/// <returns>Message result code</returns>
public static IntPtr SendKeyClick(IntPtr windowHandle, KeyboardKeys key, ModifierKeys modifiers, bool pressed)
{
IntPtr rc = IntPtr.Zero;
uint msg = GetKeypressWM(pressed);
// lParam is always 0 for button press and <shrug> for released
IntPtr lParam = pressed ? IntPtr.Zero : (IntPtr)0xC0000000;
// If the key is pressed, press the modifier first
if (pressed)
{
SendModifierKeys(windowHandle, modifiers, msg, lParam);
}
rc = SendMessage(windowHandle, msg, VirtualKeyFromKey(key), lParam);
// If the key is released, release the modifier last
if (!pressed)
{
SendModifierKeys(windowHandle, modifiers, msg, lParam);
}
return rc;
}
public void InitializeKeyboardDefaults()
{
KeyDef = new KeyboardKeys();
KeyAltDef = new KeyboardKeys();
KeyDef.DpadDown = "DOWN";
KeyDef.DpadUp = "UP";
KeyDef.DpadLeft = "LEFT";
KeyDef.DpadRight = "RIGHT";
KeyDef.ButtonY = "KEY_I";
KeyDef.ButtonX = "KEY_J";
KeyDef.ButtonA = "KEY_K";
KeyDef.ButtonB = "KEY_L";
KeyDef.LXleft = "KEY_A";
KeyDef.LXright = "KEY_D";
KeyDef.LYup = "KEY_W";
KeyDef.LYdown = "KEY_S";
KeyDef.RXleft = "NUMPAD4";
KeyDef.RXright = "NUMPAD6";
KeyDef.RYup = "NUMPAD8";
KeyDef.RYdown = "NUMPAD2";
KeyDef.Modifier = "LSHIFT";
KeyDef.RightModifier = "RSHIFT";
KeyDef.ButtonBack = "ESCAPE";
KeyDef.ButtonHome = "F2";
KeyDef.ButtonStart = "F3";
KeyAltDef.ButtonBack = "F4";
KeyAltDef.ButtonA = "RETURN";
KeyAltDef.ButtonB = "BACK";
}
/// <summary>
/// Returns true if the specified key is pressed.
/// Flag EnableUserInput must be enabled.
/// Unfortunately this does not read the raw keyboard input yet - when you hold down a key,
/// the IsKeyPressed function is true for a frame, then false for a few frames,
/// and then alternates between true and false (as if you were holding down the key in a text box).
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool IsKeyPressed(KeyboardKeys key) {
return SWIG.BWAPI.bwapi.Broodwar.getKeyState((int)key);
}
private static Keys ConvertToXnaKey(KeyboardKeys key)
{
return (Keys)(int)key;
}
public override bool IsKeyDown(KeyboardKeys key)
{
return this.states.IsKeyDown(ConvertToXnaKey(key));
}
public bool IsKeyDown(KeyboardKeys whichKey)
{
return _parentForm.IsKeyDown(whichKey);
}
static IntPtr VirtualKeyFromKey(KeyboardKeys key)
{
return (IntPtr)key;
}
public abstract bool IsKeyDown(KeyboardKeys key);
public bool IsKeyDown(KeyboardKeys whichKey)
{
return _keyboard.KeyStates[whichKey] == KeyState.Down;
}
public void KeyDown(KeyboardKeys key)
{
}
public void KeyUp(KeyboardKeys key)
{
}
