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; }
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); }