public RitualKey(KeyCodes code = KeyCodes.None)
{
keyCode = code;
earnedByJoy = new bool[2];
earnedByJoy[0] = false;
earnedByJoy[1] = false;
}
/// <summary>
/// Constructor for keyboard buttons.
/// </summary>
/// <param name="code"></param>
/// <param name="onPress"></param>
public ButtonTrigger(KeyCodes code, bool onPress)
{
this.deviceId = 0;
this.deviceType = InputDeviceType.Keyboard;
this.buttonId = (uint)code;
this.whenButtonPressed = onPress;
}
protected override void OnKeyPressInternal(IPointer cursor, KeyCodes code,
KeyboardModifiers modifiers, InputEventModifier eventModifiers)
{
base.OnKeyPressInternal(cursor, code, modifiers, eventModifiers);
// We are focused.
animationState.TransistTo(CommonStyleStates.Focused);
if (code == KeyCodes.C && (modifiers & KeyboardModifiers.LCtrl) != 0)
{
if (selectedRange.Y < selectedRange.X)
{
return;
}
// We have a copy event.
Action3 <Label, Vector2i, StringBuilder> t = onTextCopy;
StringBuilder b = new StringBuilder(SelectedText);
// Events may alter copy or react on it.
if (t != null)
{
t(this, selectedRange, b);
}
// We add copy to cursor.
AttachedData attachedData = new AttachedData();
attachedData.ApplicationID = Guid.Empty; //< FIXME
attachedData.Data = b.ToString();
attachedData.Representation = null;
// We attach data.
cursor.AttachData(attachedData);
}
}
public void RemoveKeyCode(int keyCode, bool removeAll)
{
if (KeyCodes.Contains(keyCode))
{
if (!removeAll)
{
KeyCodes.Remove(keyCode);
}
else
{
int startCount = KeyCodes.Count;
for (int i = startCount - 1; i >= 0; i--)
{
if (KeyCodes[i] == keyCode)
{
KeyCodes.RemoveAt(i);
}
}
}
}
else
{
Debug.LogWarning("Can't remove key code '" + keyCode +
"' because it doesn't exist.");
}
}
private Input[] GetSingleKeyDownSequence(KeyCodes keyCode)
{
Input downInput = new Input();
downInput.type = (int)InputType.Keyboard;
downInput.union = new InputUnion {
ki = new KeyboardInput {
vk = 0,
wScan = (ushort)keyCode,
dwFlags = SCANCODE,
time = 0,
dwExtraInfo = IntPtr.Zero
}
};
Input upInput = new Input();
upInput.type = (int)InputType.Keyboard;
upInput.union = new InputUnion {
ki = new KeyboardInput {
vk = 0,
wScan = (ushort)keyCode,
dwFlags = KEYUP | SCANCODE,
time = 0,
dwExtraInfo = IntPtr.Zero
}
};
return(new Input[] { downInput, upInput });
}
public void Construct(DialogueAction action, KeyCode hotkey)
{
this.action = action;
this.hotkey = hotkey;
this.text.text = $"{KeyCodes.GetLabel(this.hotkey)}. {this.action.Text}";
}
public void SetHotkey(KeyCode hotkey)
{
this.hotkey = hotkey;
this.hotkeyBadge.gameObject.SetActive(true);
this.hotkeyText.text = KeyCodes.GetLabel(this.hotkey);
}
public void addGlobalKeyAction(String name, KeyCodes k1, KeyCodes?k2 = null, KeyCodes?k3 = null,
Action OnPress = null, Action OnRelease = null, Action OnHold = null)
{
KeyBundle keyBundle;
if (k2 == null)
{
keyBundle = new KeyBundle(k1);
}
else if (k3 == null)
{
keyBundle = new KeyBundle((KeyCodes)k2, k1);
}
else
{
keyBundle = new KeyBundle((KeyCodes)k3, (KeyCodes)k2, k1);
}
var keyAction = new KeyAction(name, OnPress, new HashSet <KeyBundle>()
{
keyBundle
});
keyAction.releaseAction = OnRelease;
keyAction.holdAction = OnHold;
Keybinds.Add(keyBundle, keyAction);
}
public void ProcessKeyboard()
{
foreach (Keys k in Enum.GetValues(typeof(Keys)))
{
if (KeyPressEvent(k))
{
KeyCodes kc = (KeyCodes)k;
//Console.WriteLine(kc); //======================//======================//======================//======================//======================
if (!PressedKeys.Contains(kc) && PressedKeys.Count < 3)
{
//PressedKeys.Push(kc);
PressedKeys.Add(kc);
TryAction();
}
//PrintPressedKeys();
}
}
for (int i = PressedKeys.Count - 1; i >= 0; i--)
{
KeyCodes key = PressedKeys.ElementAt(i);
if (KeyReleaseEvent((Keys)key))
{
//while (PressedKeys.ElementAt(PressedKeys.Count) != key) PressedKeys.Pop();
//PressedKeys.Pop();
PressedKeys.Remove(key);
//PrintPressedKeys(true);
break;
}
}
}
public KeyBundle(KeyCodes effectiveKey, KeyCodes?mod1 = null, KeyCodes?mod2 = null)
{
this.effectiveKey = effectiveKey;
this.mod1 = mod1;
this.mod2 = mod2;
if (mod1 == null)
{
if (mod2 != null)
{
this.mod1 = mod1;
this.mod2 = mod2;
throw new ArgumentException();
}
}
else
{
if (mod2 != null)
{
//this.mod2 = mod2;
if (mod1 > mod2)
{
this.mod1 = mod2;
this.mod2 = mod1;
}
}
}
}
/// <summary>
/// Grabs the first key that is currently pressed and returns it as a character.
/// </summary>
/// <returns>ASCII character of the first key current pressed.</returns>
public static char GetChar()
{
while (_grabIndex < 160)
{
KeyCodes keyCode = GetKey();
if ((int)keyCode != 0)
{
char chr = NativeMethods.VirtualKeyToChar((uint)_virtualKeys[(int)keyCode]);
if (chr != '\0')
{
if (_lastKey == keyCode && _fastKeyTimer.DurationMillisecond > _fastKeyDelay)
{
return(chr);
}
else
{
if (_lastKey != keyCode)
{
_fastKeyTimer.Restart();
_lastKey = keyCode;
return(chr);
}
return('\0');
}
}
}
}
_fastKeyTimer.Restart();
_lastKey = (KeyCodes)0;
return('\0');
}
protected void addProcessKeyAction(String name, KeyCodes k1, KeyCodes?k2 = null, KeyCodes?k3 = null,
Action OnPress = null, Action OnRelease = null, Action OnHold = null)
{
KeyBundle keyBundle;
if (k2 == null)
{
keyBundle = new KeyBundle(k1);
}
else if (k3 == null)
{
keyBundle = new KeyBundle((KeyCodes)k2, k1);
}
else
{
keyBundle = new KeyBundle((KeyCodes)k3, (KeyCodes)k2, k1);
}
var keyAction = new KeyAction(name, OnPress, new HashSet <KeyBundle>()
{
keyBundle
});
keyAction.releaseAction = OnRelease;
keyAction.holdAction = OnHold;
processKeyActions.Add(keyAction, keyBundle);
}
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="keyCode">KeyCode of key that fired this event.</param>
/// <param name="pressed">If this event was fired by pressing or releasing the event.</param>
/// <param name="mx">Position of the mouse on the x-axis.</param>
/// <param name="my">Position of the mouse on the y-axis.</param>
/// <param name="mz">Position of the mouse on the z-axis.</param>
public InputEventData(KeyCodes keyCode, bool pressed, int mx, int my, int mz)
{
_keyCode = keyCode;
_pressed = pressed;
_mouseX = mx;
_mouseY = my;
_mouseZ = mz;
}
/// <summary>
/// Initializes a new instance of this class.
/// </summary>
/// <param name="keyCode">KeyCode of key that fired this event.</param>
/// <param name="pressed">If this event was fired by pressing or releasing the event.</param>
/// <param name="mx">Position of the mouse on the x-axis.</param>
/// <param name="my">Position of the mouse on the y-axis.</param>
/// <param name="mz">Position of the mouse on the z-axis.</param>
public InputEventData(KeyCodes keyCode, bool pressed, int mx, int my, int mz)
{
_keyCode = keyCode;
_pressed = pressed;
_mouseX = mx;
_mouseY = my;
_mouseZ = mz;
}
public KeyInput(List <KeyCode> newKeyCode, KeyStateEnum newKeyState, CheckingModeEnum newCheckingKeyMode, System.Action newOnKeyAction, OccurrenceModeEnum newOccurrenceMode = OccurrenceModeEnum.KEY_HAS_OCCUR)
{
KeyCodes.AddRange(newKeyCode);
KeyState = newKeyState;
CheckingKeyMode = newCheckingKeyMode;
OnKeyAction = newOnKeyAction;
OccurrenceMode = newOccurrenceMode;
}
public static void unbind(KeyCodes keyCode)
{
if (InputList.Exists(i => i.KeyCode == keyCode))
{
KeyModel Input = InputList.Find(i => i.KeyCode == keyCode);
InputList.Remove(Input);
}
}
/// <summary>
/// Retruns true if the given mouse button is currently down.
/// </summary>
/// <param name="key">Mouse key code of key to check.</param>
/// <returns>True if mouse key is currently down.</returns>
private bool MouseDown(KeyCodes key)
{
if (_mouseState.GetMouseButtons() == null)
{
return(false);
}
return(_mouseState.GetMouseButtons()[((int)key) - 160] != 0);
}
public string GetBinding(KeyCodes k, ModifierKeys m)
{
// TODO: support actions for simple modifier keys?
string keyStr = KeyBindings.GetKeyString(k);
if (keyStr == null)
return null;
return GetBinding(keyStr, m);
}
/// <summary>
/// 用於發送一個虛擬按鍵。
/// </summary>
/// <param name="SendCode">要傳送"按下"指令的按鍵代碼</param>
/// <returns></returns>
public bool PressKey(KeyCodes SendCode)
{
bool a = SendKey(SendCode, KeyStatus.KeyDown);
Thread.Sleep(1);
bool b = SendKey(SendCode, KeyStatus.KeyUP);
return(a || b);
}
/// <summary>
/// Binds a keyboard key to a given name.
/// </summary>
/// <param name="key">Key to bind.</param>
/// <param name="name">Name to bind key to.</param>
public static void BindKey(string name, KeyCodes key)
{
name = name.ToLower();
if (_keyBindings.Contains(name) == true)
{
_keyBindings.Remove(name);
}
_keyBindings.Add(name, key);
}
// метод удаления кнопки из списка
public static void Unbind(KeyCodes keyCode)
{
//тут просто находим объект с данным кодом в списке и удаляем
if (InputList.Exists(i => i.KeyCode == keyCode))
{
KeyModel Input = InputList.Find(i => i.KeyCode == keyCode);
InputList.Remove(Input);
}
}
void IUserInteractive.OnKeyPress(IPointer cursor, KeyCodes code, SharpMedia.Input.KeyboardModifiers modifiers, InputEventModifier eventModifiers)
{
IWidget focus = FocusedWidget;
if (focus != null)
{
focus.OnKeyPress(cursor, code, modifiers, eventModifiers);
}
}
void IUserInteractive.OnKeyRelease(IPointer cursor, KeyCodes code, SharpMedia.Input.KeyboardModifiers modifiers)
{
IWidget focus = FocusedWidget;
if (focus != null)
{
focus.OnKeyRelease(cursor, code, modifiers);
}
}
public override void HandleInputUp(KeyCodes code)
{
switch (code)
{
case KeyCodes.Escape:
_shouldExitToMainMenu = true;
break;
}
}
public static KeyCodes KeyCodes_normalizeMacWebKitKeyCode(KeyCodes keyCode)
{
switch (keyCode) {
case goog.events.KeyCodes.MAC_WK_CMD_RIGHT: // 93
return goog.events.KeyCodes.META; // 91
default:
return keyCode;
}
}
public override string ToString()
{
string ans = KeyCodes.ToShortString(key);
foreach (var mod in modifiers)
{
ans = KeyCodes.ToShortString(mod) + "+" + ans;
}
return(ans);
}
public void AddKeyCodes(KeyCode[] keycodes)
{
foreach (KeyCode keycode in keycodes)
{
if (!KeyCodes.Contains(keycode))
{
KeyCodes.Add(keycode);
}
}
}
public Events(KeyCodes keyCode, HTMLDivElement wrapper)
{
if (wrapper == null)
{
throw new ArgumentNullException(nameof(wrapper));
}
_keyCode = (int)keyCode;
_wrapper = wrapper;
}
public async static Task <bool> SendKey(IntPtr hwnd, KeyCodes key, int Delay)
{
bool result;
result = PostMessage(hwnd, (uint)KeyEvents.WM_KEYDOWN, (char)key, 1);
await Task.Delay(Delay);
result = PostMessage(hwnd, (uint)KeyEvents.WM_KEYUP, (char)key, 0);
return(result);
}
public string GetBinding(KeyCodes k, ModifierKeys m)
{
// TODO: support actions for simple modifier keys?
string keyStr = KeyBindings.GetKeyString(k);
if (keyStr == null)
{
return(null);
}
return(GetBinding(keyStr, m));
}
public KeyboardEmulator PressKey(KeyCodes keyCode, uint count = 1)
{
if (count < 1)
{
throw new ArgumentOutOfRangeException(nameof(count), "Must be more than zero");
}
this.SendKeyboardKeys($"{{{keyCode.ToString()} {count}}}");
return(this);
}
public void AddKeyCode(int keyCode, bool addIfNew)
{
if (addIfNew)
{
KeyCodes.AddIfNew(keyCode);
}
else
{
KeyCodes.Add(keyCode);
}
}
private void initilizeKeyboard()
{
this.KeyDown += (o, e) =>
{
switch (e.Key)
{
case System.Windows.Input.Key.Left:
_gamePad |= KeyCodes.KEY_LEFT;
break;
case System.Windows.Input.Key.Right:
_gamePad |= KeyCodes.KEY_RIGHT;
break;
case System.Windows.Input.Key.Up:
_gamePad |= KeyCodes.KEY_UP;
break;
case System.Windows.Input.Key.Down:
_gamePad |= KeyCodes.KEY_DOWN;
break;
case System.Windows.Input.Key.Escape:
_gamePad |= KeyCodes.KEY_ESC;
break;
}
};
this.KeyUp += (o, e) =>
{
switch (e.Key)
{
case System.Windows.Input.Key.Left:
_gamePad &= ~KeyCodes.KEY_LEFT;
break;
case System.Windows.Input.Key.Right:
_gamePad &= ~KeyCodes.KEY_RIGHT;
break;
case System.Windows.Input.Key.Up:
_gamePad &= ~KeyCodes.KEY_UP;
break;
case System.Windows.Input.Key.Down:
_gamePad &= ~KeyCodes.KEY_DOWN;
break;
case System.Windows.Input.Key.Escape:
_gamePad &= ~KeyCodes.KEY_ESC;
break;
}
};
}
void cf_OnKeyDown(CrystalFontz635 api, KeyCodes pressedKeys)
{
switch (pressedKeys) {
case KeyCodes.Up:
if (index - 1 > 0) {
index--;
}
break;
case KeyCodes.Down:
if (index + 1 < drives.Length) {
index++;
}
break;
}
}
public static LaneKeyCode KeyCodeToLane(KeyCodes keyCode)
{
switch (keyCode)
{
case KeyCodes.A:
return LaneKeyCode.Y;
case KeyCodes.B:
return LaneKeyCode.X;
case KeyCodes.X:
return LaneKeyCode.B;
case KeyCodes.Y:
return LaneKeyCode.A;
default:
return LaneKeyCode.A;
}
}
public static bool IsAxisPressed(KeyCodes keyCode, float value)
{
switch (keyCode)
{
case KeyCodes.LT:
case KeyCodes.Down:
case KeyCodes.Left:
if (value <= -0.3f)
{
return true;
}
break;
default:
return value >= 0.3f;
}
return false;
}
public void EnterInput(int joystick, KeyCodes keyCode)
{
int ritualIndex = GetCurrentIndex(joystick) + 1;
if (ritual[ritualIndex].keyCode == keyCode)
{
ritual[ritualIndex].earnedByJoy[joystick] = true;
if (OnPress != null)
{
OnPress(joystick, ritualIndex);
}
}
else
{
Reset(joystick);
}
}
public void addGlobalKeyAction(String name, KeyCodes k1, KeyCodes? k2 = null, KeyCodes? k3 = null, Action OnPress = null, Action OnRelease = null, Action OnHold = null)
{
KeyBundle keyBundle;
if (k2 == null) keyBundle = new KeyBundle(k1);
else if (k3 == null) keyBundle = new KeyBundle((KeyCodes)k2, k1);
else keyBundle = new KeyBundle((KeyCodes)k3, (KeyCodes)k2, k1);
var keyAction = new KeyAction(name, OnPress, new HashSet<KeyBundle>() { keyBundle });
keyAction.releaseAction = OnRelease;
keyAction.holdAction = OnHold;
Keybinds.Add(keyBundle, keyAction);
}
public KeyBundle(KeyCodes effectiveKey, KeyCodes? mod1 = null, KeyCodes? mod2 = null)
{
this.effectiveKey = effectiveKey;
this.mod1 = mod1;
this.mod2 = mod2;
if (mod1 == null)
{
if (mod2 != null) { this.mod1 = mod1; this.mod2 = mod2; throw new ArgumentException(); }
}
else
{
if (mod2 != null)
{
//this.mod2 = mod2;
if (mod1 > mod2)
{
this.mod1 = mod2;
this.mod2 = mod1;
}
}
}
}
/// <summary>
/// Grabs the first key that is currently pressed and returns it as a character.
/// </summary>
/// <returns>ASCII character of the first key current pressed.</returns>
public static char GetChar()
{
while (_grabIndex < 160)
{
KeyCodes keyCode = GetKey();
if ((int)keyCode != 0)
{
char chr = NativeMethods.VirtualKeyToChar((uint)_virtualKeys[(int)keyCode]);
if (chr != '\0')
{
if (_lastKey == keyCode && _fastKeyTimer.DurationMillisecond > _fastKeyDelay)
return chr;
else
{
if (_lastKey != keyCode)
{
_fastKeyTimer.Restart();
_lastKey = keyCode;
return chr;
}
return '\0';
}
}
}
}
_fastKeyTimer.Restart();
_lastKey = (KeyCodes)0;
return '\0';
}
public bool IsKeyDownEvent(KeyCodes key)
{
if (!_keyEventTargets.Contains(key)) _keyEventTargets.Add(key);
return !_previousKeyStates[(int)key] && _currentKeyStates[(int)key];
}
/// <summary>
/// Used to convert an Axiom.Input.KeyCodes enum val to a Key enum val.
/// </summary>
/// <param name="key">Axiom keyboard code to query.</param>
/// <returns>
/// The equivalent enum value in the Key enum.
/// </returns>
private static Key ConvertKeyEnum( KeyCodes key )
{
Key dinputKey = 0;
switch ( key )
{
case KeyCodes.A:
dinputKey = Key.A;
break;
case KeyCodes.B:
dinputKey = Key.B;
break;
case KeyCodes.C:
dinputKey = Key.C;
break;
case KeyCodes.D:
dinputKey = Key.D;
break;
case KeyCodes.E:
dinputKey = Key.E;
break;
case KeyCodes.F:
dinputKey = Key.F;
break;
case KeyCodes.G:
dinputKey = Key.G;
break;
case KeyCodes.H:
dinputKey = Key.H;
break;
case KeyCodes.I:
dinputKey = Key.I;
break;
case KeyCodes.J:
dinputKey = Key.J;
break;
case KeyCodes.K:
dinputKey = Key.K;
break;
case KeyCodes.L:
dinputKey = Key.L;
break;
case KeyCodes.M:
dinputKey = Key.M;
break;
case KeyCodes.N:
dinputKey = Key.N;
break;
case KeyCodes.O:
dinputKey = Key.O;
break;
case KeyCodes.P:
dinputKey = Key.P;
break;
case KeyCodes.Q:
dinputKey = Key.Q;
break;
case KeyCodes.R:
dinputKey = Key.R;
break;
case KeyCodes.S:
dinputKey = Key.S;
break;
case KeyCodes.T:
dinputKey = Key.T;
break;
case KeyCodes.U:
dinputKey = Key.U;
break;
case KeyCodes.V:
dinputKey = Key.V;
break;
case KeyCodes.W:
dinputKey = Key.W;
break;
case KeyCodes.X:
dinputKey = Key.X;
break;
case KeyCodes.Y:
dinputKey = Key.Y;
break;
case KeyCodes.Z:
dinputKey = Key.Z;
break;
case KeyCodes.Left:
dinputKey = Key.Left;
break;
case KeyCodes.Right:
dinputKey = Key.Right;
break;
case KeyCodes.Up:
dinputKey = Key.Up;
break;
case KeyCodes.Down:
dinputKey = Key.Down;
break;
case KeyCodes.Escape:
dinputKey = Key.Escape;
break;
case KeyCodes.F1:
dinputKey = Key.F1;
break;
case KeyCodes.F2:
dinputKey = Key.F2;
break;
case KeyCodes.F3:
dinputKey = Key.F3;
break;
case KeyCodes.F4:
dinputKey = Key.F4;
break;
case KeyCodes.F5:
dinputKey = Key.F5;
break;
case KeyCodes.F6:
dinputKey = Key.F6;
break;
case KeyCodes.F7:
dinputKey = Key.F7;
break;
case KeyCodes.F8:
dinputKey = Key.F8;
break;
case KeyCodes.F9:
dinputKey = Key.F9;
break;
case KeyCodes.F10:
dinputKey = Key.F10;
break;
case KeyCodes.D0:
dinputKey = Key.D0;
break;
case KeyCodes.D1:
dinputKey = Key.D1;
break;
case KeyCodes.D2:
dinputKey = Key.D2;
break;
case KeyCodes.D3:
dinputKey = Key.D3;
break;
case KeyCodes.D4:
dinputKey = Key.D4;
break;
case KeyCodes.D5:
dinputKey = Key.D5;
break;
case KeyCodes.D6:
dinputKey = Key.D6;
break;
case KeyCodes.D7:
dinputKey = Key.D7;
break;
case KeyCodes.D8:
dinputKey = Key.D8;
break;
case KeyCodes.D9:
dinputKey = Key.D9;
break;
case KeyCodes.F11:
dinputKey = Key.F11;
break;
case KeyCodes.F12:
dinputKey = Key.F12;
break;
case KeyCodes.Enter:
dinputKey = Key.Enter;
break;
case KeyCodes.Tab:
dinputKey = Key.Tab;
break;
case KeyCodes.LeftShift:
case KeyCodes.RightShift:
dinputKey = Key.Shift;
break;
case KeyCodes.LeftControl:
case KeyCodes.RightControl:
dinputKey = Key.Ctrl;
break;
//case KeyCodes.Period:
// dinputKey = Key.Period;
// break;
//case KeyCodes.Comma:
// dinputKey = Key.Comma;
// break;
case KeyCodes.Home:
dinputKey = Key.Home;
break;
case KeyCodes.PageUp:
dinputKey = Key.PageUp;
break;
case KeyCodes.PageDown:
dinputKey = Key.PageDown;
break;
case KeyCodes.End:
dinputKey = Key.End;
break;
//case KeyCodes.Semicolon:
// dinputKey = Key.Semicolon;
// break;
case KeyCodes.Subtract:
dinputKey = Key.Subtract;
break;
case KeyCodes.Add:
dinputKey = Key.Add;
break;
case KeyCodes.Backspace:
dinputKey = Key.Back;
break;
case KeyCodes.Delete:
dinputKey = Key.Delete;
break;
case KeyCodes.Insert:
dinputKey = Key.Insert;
break;
case KeyCodes.LeftAlt:
case KeyCodes.RightAlt:
dinputKey = Key.Alt;
break;
case KeyCodes.Space:
dinputKey = Key.Space;
break;
//case KeyCodes.Tilde:
// dinputKey = Key.Grave;
// break;
//case KeyCodes.OpenBracket:
// dinputKey = Key.LeftBracket;
// break;
//case KeyCodes.CloseBracket:
// dinputKey = Key.RightBracket;
// break;
//case KeyCodes.QuestionMark:
// dinputKey = Key.Slash;
// break;
//case KeyCodes.Quotes:
// dinputKey = Key.Apostrophe;
// break;
//case KeyCodes.Backslash:
// dinputKey = Key.Backslash;
// break;
case KeyCodes.NumPad0:
dinputKey = Key.NumPad0;
break;
case KeyCodes.NumPad1:
dinputKey = Key.NumPad1;
break;
case KeyCodes.NumPad2:
dinputKey = Key.NumPad2;
break;
case KeyCodes.NumPad3:
dinputKey = Key.NumPad3;
break;
case KeyCodes.NumPad4:
dinputKey = Key.NumPad4;
break;
case KeyCodes.NumPad5:
dinputKey = Key.NumPad5;
break;
case KeyCodes.NumPad6:
dinputKey = Key.NumPad6;
break;
case KeyCodes.NumPad7:
dinputKey = Key.NumPad7;
break;
case KeyCodes.NumPad8:
dinputKey = Key.NumPad8;
break;
case KeyCodes.NumPad9:
dinputKey = Key.NumPad9;
break;
}
return dinputKey;
}
/// <summary>
/// Checks the current keyboard state to see if the specified key is pressed.
/// </summary>
/// <param name="key">KeyCode to check.</param>
/// <returns>true if the key is down, false otherwise.</returns>
public override bool IsKeyPressed(KeyCodes key)
{
int sdlKey = ConvertKeyEnum(key);
return keyboardState[sdlKey] != 0;
}
void cf_OnKeyDown(CrystalFontz635 api, KeyCodes pressedKeys)
{
switch (pressedKeys) {
case KeyCodes.Left:
if (display - 1 >= 1)
display--;
break;
case KeyCodes.Right:
if (display + 1 <= 3)
display++;
break;
}
Draw(TimeSpan.MaxValue);
}
/// <summary>
/// Helper method for running logic on a key change.
/// </summary>
/// <param name="key">Code of the key being changed</param>
/// <param name="down">True if the key is being pressed down, false if being released.</param>
protected void KeyChanged( KeyCodes key, bool down )
{
if ( down )
{
switch ( key )
{
case KeyCodes.LeftAlt:
case KeyCodes.RightAlt:
this.modifiers |= ModifierKeys.Alt;
break;
case KeyCodes.LeftShift:
case KeyCodes.RightShift:
this.modifiers |= ModifierKeys.Shift;
break;
case KeyCodes.LeftControl:
case KeyCodes.RightControl:
this.modifiers |= ModifierKeys.Control;
break;
}
var e = new Axiom.Input.KeyEventArgs( key, this.modifiers );
OnKeyDown( e );
}
else
{
switch ( key )
{
case KeyCodes.LeftAlt:
case KeyCodes.RightAlt:
this.modifiers &= ~ModifierKeys.Alt;
break;
case KeyCodes.LeftShift:
case KeyCodes.RightShift:
this.modifiers &= ~ModifierKeys.Shift;
break;
case KeyCodes.LeftControl:
case KeyCodes.RightControl:
this.modifiers &= ~ModifierKeys.Control;
break;
}
var e = new Axiom.Input.KeyEventArgs( key, this.modifiers );
OnKeyUp( e );
}
}
/// <summary>
/// Given a key code enum value, the corresponding character is returned.
/// </summary>
public static char GetKeyChar( KeyCodes keyCode, ModifierKeys modifiers )
{
var isShiftDown = ( modifiers & ModifierKeys.Shift ) > 0;
switch ( keyCode )
{
case KeyCodes.A:
return isShiftDown ? 'A' : 'a';
case KeyCodes.B:
return isShiftDown ? 'B' : 'b';
case KeyCodes.C:
return isShiftDown ? 'C' : 'c';
case KeyCodes.D:
return isShiftDown ? 'D' : 'd';
case KeyCodes.E:
return isShiftDown ? 'E' : 'e';
case KeyCodes.F:
return isShiftDown ? 'F' : 'f';
case KeyCodes.G:
return isShiftDown ? 'G' : 'g';
case KeyCodes.H:
return isShiftDown ? 'H' : 'h';
case KeyCodes.I:
return isShiftDown ? 'I' : 'i';
case KeyCodes.J:
return isShiftDown ? 'J' : 'j';
case KeyCodes.K:
return isShiftDown ? 'K' : 'k';
case KeyCodes.L:
return isShiftDown ? 'L' : 'l';
case KeyCodes.M:
return isShiftDown ? 'M' : 'm';
case KeyCodes.N:
return isShiftDown ? 'N' : 'n';
case KeyCodes.O:
return isShiftDown ? 'O' : 'o';
case KeyCodes.P:
return isShiftDown ? 'P' : 'p';
case KeyCodes.Q:
return isShiftDown ? 'Q' : 'q';
case KeyCodes.R:
return isShiftDown ? 'R' : 'r';
case KeyCodes.S:
return isShiftDown ? 'S' : 's';
case KeyCodes.T:
return isShiftDown ? 'T' : 't';
case KeyCodes.U:
return isShiftDown ? 'U' : 'u';
case KeyCodes.V:
return isShiftDown ? 'V' : 'v';
case KeyCodes.W:
return isShiftDown ? 'W' : 'w';
case KeyCodes.X:
return isShiftDown ? 'X' : 'x';
case KeyCodes.Y:
return isShiftDown ? 'Y' : 'y';
case KeyCodes.Z:
return isShiftDown ? 'Z' : 'z';
case KeyCodes.Space:
return ' ';
case KeyCodes.QuestionMark:
return isShiftDown ? '?' : '/';
case KeyCodes.Comma:
return isShiftDown ? '<' : ',';
case KeyCodes.Period:
return isShiftDown ? '>' : '.';
case KeyCodes.D0:
return isShiftDown ? ')' : '0';
case KeyCodes.D1:
return isShiftDown ? '!' : '1';
case KeyCodes.D2:
return isShiftDown ? '@' : '2';
case KeyCodes.D3:
return isShiftDown ? '#' : '3';
case KeyCodes.D4:
return isShiftDown ? '$' : '4';
case KeyCodes.D5:
return isShiftDown ? '%' : '5';
case KeyCodes.D6:
return isShiftDown ? '^' : '6';
case KeyCodes.D7:
return isShiftDown ? '&' : '7';
case KeyCodes.D8:
return isShiftDown ? '*' : '8';
case KeyCodes.D9:
return isShiftDown ? '(' : '9';
case KeyCodes.Semicolon:
return isShiftDown ? ':' : ';';
case KeyCodes.Quotes:
// laziness :)
return isShiftDown ? '"' : "'"[ 0 ];
case KeyCodes.OpenBracket:
return isShiftDown ? '{' : '[';
case KeyCodes.CloseBracket:
return isShiftDown ? '}' : ']';
case KeyCodes.Backslash:
return isShiftDown ? '|' : '\\';
case KeyCodes.Plus:
return isShiftDown ? '+' : '=';
case KeyCodes.Subtract:
return isShiftDown ? '_' : '-';
case KeyCodes.Tilde:
return isShiftDown ? '~' : '`';
default:
return (char)0;
}
}
/// <summary>
/// Used to convert an Axiom.Input.KeyCodes enum val to a OpenTK enum val.
/// </summary>
/// <param name="key">Axiom keyboard code to query.</param>
/// <returns>The equivalent enum value in the OpenTK enum.</returns>
private Key ConvertKeyEnum( KeyCodes key )
{
Key k = 0;
switch ( key )
{
case KeyCodes.A:
k = Key.A;
break;
case KeyCodes.B:
k = Key.B;
break;
case KeyCodes.C:
k = Key.C;
break;
case KeyCodes.D:
k = Key.D;
break;
case KeyCodes.E:
k = Key.E;
break;
case KeyCodes.F:
k = Key.F;
break;
case KeyCodes.G:
k = Key.G;
break;
case KeyCodes.H:
k = Key.H;
break;
case KeyCodes.I:
k = Key.I;
break;
case KeyCodes.J:
k = Key.J;
break;
case KeyCodes.K:
k = Key.K;
break;
case KeyCodes.L:
k = Key.L;
break;
case KeyCodes.M:
k = Key.M;
break;
case KeyCodes.N:
k = Key.N;
break;
case KeyCodes.O:
k = Key.O;
break;
case KeyCodes.P:
k = Key.P;
break;
case KeyCodes.Q:
k = Key.Q;
break;
case KeyCodes.R:
k = Key.R;
break;
case KeyCodes.S:
k = Key.S;
break;
case KeyCodes.T:
k = Key.T;
break;
case KeyCodes.U:
k = Key.U;
break;
case KeyCodes.V:
k = Key.V;
break;
case KeyCodes.W:
k = Key.W;
break;
case KeyCodes.X:
k = Key.X;
break;
case KeyCodes.Y:
k = Key.Y;
break;
case KeyCodes.Z:
k = Key.Z;
break;
case KeyCodes.Left:
k = Key.Left;
break;
case KeyCodes.Right:
k = Key.Right;
break;
case KeyCodes.Up:
k = Key.Up;
break;
case KeyCodes.Down:
k = Key.Down;
break;
case KeyCodes.Escape:
k = Key.Escape;
break;
case KeyCodes.F1:
k = Key.F1;
break;
case KeyCodes.F2:
k = Key.F2;
break;
case KeyCodes.F3:
k = Key.F3;
break;
case KeyCodes.F4:
k = Key.F4;
break;
case KeyCodes.F5:
k = Key.F5;
break;
case KeyCodes.F6:
k = Key.F6;
break;
case KeyCodes.F7:
k = Key.F7;
break;
case KeyCodes.F8:
k = Key.F8;
break;
case KeyCodes.F9:
k = Key.F9;
break;
case KeyCodes.F10:
k = Key.F10;
break;
case KeyCodes.D0:
k = Key.Number0;
break;
case KeyCodes.D1:
k = Key.Number1;
break;
case KeyCodes.D2:
k = Key.Number2;
break;
case KeyCodes.D3:
k = Key.Number3;
break;
case KeyCodes.D4:
k = Key.Number4;
break;
case KeyCodes.D5:
k = Key.Number5;
break;
case KeyCodes.D6:
k = Key.Number6;
break;
case KeyCodes.D7:
k = Key.Number7;
break;
case KeyCodes.D8:
k = Key.Number8;
break;
case KeyCodes.D9:
k = Key.Number9;
break;
case KeyCodes.F11:
k = Key.F11;
break;
case KeyCodes.F12:
k = Key.F12;
break;
case KeyCodes.Enter:
k = Key.Enter;
break;
case KeyCodes.Tab:
k = Key.Tab;
break;
case KeyCodes.LeftShift:
k = Key.ShiftLeft;
break;
case KeyCodes.RightShift:
k = Key.ShiftRight;
break;
case KeyCodes.LeftControl:
k = Key.ControlLeft;
break;
case KeyCodes.RightControl:
k = Key.ControlRight;
break;
case KeyCodes.Period:
k = Key.Period;
break;
case KeyCodes.Comma:
k = Key.Comma;
break;
case KeyCodes.Home:
k = Key.Home;
break;
case KeyCodes.PageUp:
k = Key.PageUp;
break;
case KeyCodes.PageDown:
k = Key.PageDown;
break;
case KeyCodes.End:
k = Key.End;
break;
case KeyCodes.Semicolon:
k = Key.Semicolon;
break;
case KeyCodes.Subtract:
k = Key.Minus;
break;
case KeyCodes.Add:
k = Key.Plus;
break;
case KeyCodes.Backspace:
k = Key.BackSpace;
break;
case KeyCodes.Delete:
k = Key.Delete;
break;
case KeyCodes.Insert:
k = Key.Insert;
break;
case KeyCodes.LeftAlt:
k = Key.AltLeft;
break;
case KeyCodes.RightAlt:
k = Key.AltRight;
break;
case KeyCodes.Space:
k = Key.Space;
break;
case KeyCodes.Tilde:
k = Key.Tilde;
break;
case KeyCodes.OpenBracket:
k = Key.BracketLeft;
break;
case KeyCodes.CloseBracket:
k = Key.BracketRight;
break;
case KeyCodes.Plus:
k = Key.Plus;
break;
case KeyCodes.QuestionMark:
k = Key.Slash;
break;
case KeyCodes.Quotes:
k = Key.Quote;
break;
case KeyCodes.Backslash:
k = Key.BackSlash;
break;
}
return k;
}
/// <summary>
/// Checks the current keyboard state to see if the specified key is pressed.
/// </summary>
/// <param name="key">KeyCode to check.</param>
/// <returns>true if the key is down, false otherwise.</returns>
public override bool IsKeyPressed( KeyCodes key )
{
if ( keyboard == null )
return false;
return keyboard[ ConvertKeyEnum( key ) ] == true;
}
/// <summary>
/// Used to convert an Axiom.Input.KeyCodes enum val to a Sdl enum val.
/// </summary>
/// <param name="key">Axiom keyboard code to query.</param>
/// <returns>The equivalent enum value in the Sdl enum.</returns>
private int ConvertKeyEnum(KeyCodes key)
{
// TODO: Quotes
int sdlKey = 0;
switch(key) {
case KeyCodes.A:
sdlKey = Sdl.SDLK_a;
break;
case KeyCodes.B:
sdlKey = Sdl.SDLK_b;
break;
case KeyCodes.C:
sdlKey = Sdl.SDLK_c;
break;
case KeyCodes.D:
sdlKey = Sdl.SDLK_d;
break;
case KeyCodes.E:
sdlKey = Sdl.SDLK_e;
break;
case KeyCodes.F:
sdlKey = Sdl.SDLK_f;
break;
case KeyCodes.G:
sdlKey = Sdl.SDLK_g;
break;
case KeyCodes.H:
sdlKey = Sdl.SDLK_h;
break;
case KeyCodes.I:
sdlKey = Sdl.SDLK_i;
break;
case KeyCodes.J:
sdlKey = Sdl.SDLK_j;
break;
case KeyCodes.K:
sdlKey = Sdl.SDLK_k;
break;
case KeyCodes.L:
sdlKey = Sdl.SDLK_l;
break;
case KeyCodes.M:
sdlKey = Sdl.SDLK_m;
break;
case KeyCodes.N:
sdlKey = Sdl.SDLK_n;
break;
case KeyCodes.O:
sdlKey = Sdl.SDLK_o;
break;
case KeyCodes.P:
sdlKey = Sdl.SDLK_p;
break;
case KeyCodes.Q:
sdlKey = Sdl.SDLK_q;
break;
case KeyCodes.R:
sdlKey = Sdl.SDLK_r;
break;
case KeyCodes.S:
sdlKey = Sdl.SDLK_s;
break;
case KeyCodes.T:
sdlKey = Sdl.SDLK_t;
break;
case KeyCodes.U:
sdlKey = Sdl.SDLK_u;
break;
case KeyCodes.V:
sdlKey = Sdl.SDLK_v;
break;
case KeyCodes.W:
sdlKey = Sdl.SDLK_w;
break;
case KeyCodes.X:
sdlKey = Sdl.SDLK_x;
break;
case KeyCodes.Y:
sdlKey = Sdl.SDLK_y;
break;
case KeyCodes.Z:
sdlKey = Sdl.SDLK_z;
break;
case KeyCodes.Left :
sdlKey = Sdl.SDLK_LEFT;
break;
case KeyCodes.Right:
sdlKey = Sdl.SDLK_RIGHT;
break;
case KeyCodes.Up:
sdlKey = Sdl.SDLK_UP;
break;
case KeyCodes.Down:
sdlKey = Sdl.SDLK_DOWN;
break;
case KeyCodes.Escape:
sdlKey = Sdl.SDLK_ESCAPE;
break;
case KeyCodes.F1:
sdlKey = Sdl.SDLK_F1;
break;
case KeyCodes.F2:
sdlKey = Sdl.SDLK_F2;
break;
case KeyCodes.F3:
sdlKey = Sdl.SDLK_F3;
break;
case KeyCodes.F4:
sdlKey = Sdl.SDLK_F4;
break;
case KeyCodes.F5:
sdlKey = Sdl.SDLK_F5;
break;
case KeyCodes.F6:
sdlKey = Sdl.SDLK_F6;
break;
case KeyCodes.F7:
sdlKey = Sdl.SDLK_F7;
break;
case KeyCodes.F8:
sdlKey = Sdl.SDLK_F8;
break;
case KeyCodes.F9:
sdlKey = Sdl.SDLK_F9;
break;
case KeyCodes.F10:
sdlKey = Sdl.SDLK_F10;
break;
case KeyCodes.D0:
sdlKey = Sdl.SDLK_0;
break;
case KeyCodes.D1:
sdlKey = Sdl.SDLK_1;
break;
case KeyCodes.D2:
sdlKey = Sdl.SDLK_2;
break;
case KeyCodes.D3:
sdlKey = Sdl.SDLK_3;
break;
case KeyCodes.D4:
sdlKey = Sdl.SDLK_4;
break;
case KeyCodes.D5:
sdlKey = Sdl.SDLK_5;
break;
case KeyCodes.D6:
sdlKey = Sdl.SDLK_6;
break;
case KeyCodes.D7:
sdlKey = Sdl.SDLK_7;
break;
case KeyCodes.D8:
sdlKey = Sdl.SDLK_8;
break;
case KeyCodes.D9:
sdlKey = Sdl.SDLK_9;
break;
case KeyCodes.F11:
sdlKey = Sdl.SDLK_F11;
break;
case KeyCodes.F12:
sdlKey = Sdl.SDLK_F12;
break;
case KeyCodes.Enter:
sdlKey = Sdl.SDLK_RETURN;
break;
case KeyCodes.Tab:
sdlKey = Sdl.SDLK_TAB;
break;
case KeyCodes.LeftShift:
sdlKey = Sdl.SDLK_LSHIFT;
break;
case KeyCodes.RightShift:
sdlKey = Sdl.SDLK_RSHIFT;
break;
case KeyCodes.LeftControl:
sdlKey = Sdl.SDLK_LCTRL;
break;
case KeyCodes.RightControl:
sdlKey = Sdl.SDLK_RCTRL;
break;
case KeyCodes.Period:
sdlKey = Sdl.SDLK_PERIOD;
break;
case KeyCodes.Comma:
sdlKey = Sdl.SDLK_COMMA;
break;
case KeyCodes.Home:
sdlKey = Sdl.SDLK_HOME;
break;
case KeyCodes.PageUp:
sdlKey = Sdl.SDLK_PAGEUP;
break;
case KeyCodes.PageDown:
sdlKey = Sdl.SDLK_PAGEDOWN;
break;
case KeyCodes.End:
sdlKey = Sdl.SDLK_END;
break;
case KeyCodes.Semicolon:
sdlKey = Sdl.SDLK_SEMICOLON;
break;
case KeyCodes.Subtract:
sdlKey = Sdl.SDLK_MINUS;
break;
case KeyCodes.Add:
sdlKey = Sdl.SDLK_PLUS;
break;
case KeyCodes.Backspace:
sdlKey = Sdl.SDLK_BACKSPACE;
break;
case KeyCodes.Delete:
sdlKey = Sdl.SDLK_DELETE;
break;
case KeyCodes.Insert:
sdlKey = Sdl.SDLK_INSERT;
break;
case KeyCodes.LeftAlt:
sdlKey = Sdl.SDLK_LALT;
break;
case KeyCodes.RightAlt:
sdlKey = Sdl.SDLK_RALT;
break;
case KeyCodes.Space:
sdlKey = Sdl.SDLK_SPACE;
break;
case KeyCodes.Tilde:
sdlKey = Sdl.SDLK_BACKQUOTE;
break;
case KeyCodes.OpenBracket:
sdlKey = Sdl.SDLK_LEFTBRACKET;
break;
case KeyCodes.CloseBracket:
sdlKey = Sdl.SDLK_RIGHTBRACKET;
break;
case KeyCodes.Plus:
sdlKey = Sdl.SDLK_EQUALS;
break;
case KeyCodes.QuestionMark:
sdlKey = Sdl.SDLK_SLASH;
break;
case KeyCodes.Quotes:
sdlKey = Sdl.SDLK_QUOTE;
break;
case KeyCodes.Backslash:
sdlKey = Sdl.SDLK_BACKSLASH;
break;
}
return sdlKey;
}
public bool CheckMouseDown(KeyCodes? keycodes)
{
if (keycodes == KeyCodes.LeftClick)
{
return newMouseState.LeftButton == ButtonState.Pressed;
}
else if (keycodes == KeyCodes.RightClick)
{
return newMouseState.RightButton == ButtonState.Pressed;
}
else if (keycodes == KeyCodes.MiddleClick)
{
return newMouseState.MiddleButton == ButtonState.Pressed;
}
else if (keycodes == KeyCodes.BackClick)
{
return newMouseState.XButton1 == ButtonState.Pressed;
}
else if (keycodes == KeyCodes.ForwardClick)
{
return newMouseState.XButton2 == ButtonState.Pressed;
}
return false;
}
public void DetectMouseButton(ButtonState newButtonState, ButtonState oldButtonState, KeyCodes press)
{
bool pressbool = newButtonState == ButtonState.Pressed && oldButtonState == ButtonState.Released;
bool releasebool = newButtonState == ButtonState.Released && oldButtonState == ButtonState.Pressed;
bool event1 = newButtonState != oldButtonState;
if (pressbool || releasebool)
{
//Console.WriteLine("----------------");
}
if (event1 && !UserInterface.tomShaneWasClicked)
{
//Console.WriteLine(newButtonState);
if (newButtonState == ButtonState.Pressed)
{
KeyCodes kc = (KeyCodes)press;
//Console.WriteLine("Yp");
if (!PressedKeys.Contains(kc) && PressedKeys.Count < 3)
{
PressedKeys.Add(kc);
TryAction();
//Console.WriteLine("New");
}
//PrintPressedKeys();
//Console.WriteLine("key__press");
}
if (newButtonState == ButtonState.Released)
{
KeyCodes kc = (KeyCodes)press;
//while (PressedKeys.ElementAt(PressedKeys.Count) != kc) PressedKeys.Pop();
//PressedKeys.Pop();
PressedKeys.Remove(kc);
//Console.WriteLine("Keyrelease");
//PrintPressedKeys(true);
}
}
}
protected void IfKeyPressed( KeyCodes key, float delay, KeyPressCommand command )
{
if ( input.IsKeyPressed( key ) && keypressDelay < 0.0f )
{
keypressDelay = delay;
command();
}
}
/// <summary>
/// Returns true if the given key has just been hit.
/// </summary>
/// <param name="key">Key code of key to check.</param>
/// <returns>True if key is pressed.</returns>
public static bool KeyHit(KeyCodes key)
{
return _hitKeys[(int)key];
}
public bool IsKeyPressed(KeyCodes key)
{
return _input.IsKeyPressed(key);
}
/// <summary>
/// Retruns true if the given key is currently down.
/// </summary>
/// <param name="key">Key code of key to check.</param>
/// <returns>True if key is currently down.</returns>
public static bool KeyDown(KeyCodes key)
{
return _driver.KeyDown(key);
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public override bool IsKeyPressed( KeyCodes key )
{
return keys[ (int)key ];
}
/// <summary>
/// Returns true if the given key has just been pressed.
/// </summary>
/// <param name="key">Key code of key to check.</param>
/// <returns>True if key is pressed.</returns>
public static bool KeyPressed(KeyCodes key)
{
return _driver.KeyPressed(key);
}
protected void IfKeyPressed( KeyCodes key, KeyPressCommand command )
{
IfKeyPressed( key, 0.5f, command );
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="key">Key that was pressed.</param>
/// <param name="modifiers">Modifier keys pressed at the time of the event.</param>
public KeyEventArgs( KeyCodes key, ModifierKeys modifiers )
: base( modifiers )
{
this.key = key;
}
/// <summary>
/// Returns true if the given key has just been released.
/// </summary>
/// <param name="key">Key code of key to check.</param>
/// <returns>True if key has just been released.</returns>
public static bool KeyReleased(KeyCodes key)
{
return _driver.KeyReleased(key);
}
