private void _keyboardManager_GlobalKeyDown(object sender, GlobalKeyEventArgs e) { if (_recognizerResults == null) { return; } if (KeyboardManager.GetModifierState() != Modifiers.None) { return; } if (e.KeyCode >= Key.D0 && e.KeyCode <= Key.D9) { int numericValue = ((int)e.KeyCode - (int)Key.D0 + 9) % 10; if (numericValue < _recognizerResults.Count) { InputRecognitionResult(numericValue); e.Handled = true; } } else if (e.KeyCode == Key.Space && _recognizerResults.Count > 0) { InputRecognitionResult(0); e.Handled = true; } else if (e.KeyCode == Key.Backspace && _recognizerResults.Count > 0) { ClearStrokes(); e.Handled = true; } }
private void OnGlobalHotkeyUp(object sender, GlobalKeyEventArgs e) { if (PendingGlobalCommand == null) { return; } var hotKey = e.HotKey; // Execute the pending command only if no modifier key is pressed or it will mess up the keystrokes // sent from the command if (InputUtil.IsSame(hotKey.Key, hotKey.Modifiers) || !InputUtil.IsModifierKey(hotKey.Key)) { // If hotKey.Key is a modifier key, that modifier key state is still down at the time this event // is fired, which may interfere with the keystrokes sent from the automation command below, so we // will have to wait a bit more TimerUtil.SetTimeOut(() => { // The automation command will probably send some keystrokes (e.g. Ctrl-V to paste text or something) // We dont want the global hook receives and processes those events, thus run this command again _winService.GlobalKeyUp -= OnGlobalHotkeyUp; PendingGlobalCommand.Execute(null); PendingGlobalCommand = null; _winService.GlobalKeyUp += OnGlobalHotkeyUp; }, 1); } }
private void GlobalKeyHook_OnKeyDown(object sender, GlobalKeyEventArgs e) { //Log modifier keys if the checkNotLogModifier checkbox is not checked. if (!(checkNotLogModifier.Checked && e.IsModifierKey)) { if (!checkNoLogKeyDown.Checked) { listLog.Items.Add(Misc.MakeKeyLog(e, Misc.KeyEventType.OnKeyUp)); } } //If checkDisableAltF4 checkbox is checked and we are pressing alt + F4, let our system know that we are handling the input which in effect disabling it. if (checkDisableAltF4.Checked && (e.Alt != ModifierKeySide.None && e.KeyCode == VirtualKeycodes.F4)) { e.Handled = true; return; } //If checkDisableNotABC checkbox is checked and we are pressing any keys besides A, B and C, let our system know that we are handling the input which in effect disabling it. if (checkDisableNotABC.Checked && (e.KeyCode < VirtualKeycodes.A || e.KeyCode > VirtualKeycodes.C)) { e.Handled = true; return; } //Reset all the tricks by checking if we pressed the A key. if (e.KeyCode == VirtualKeycodes.A) { DisableAllTricks(); return; } }
private void GlobalKeyHook_OnKeyPressed(object sender, GlobalKeyEventArgs e) { //Log modifier key press if the checkNotLogModifier checkbox is not checked. if (!(checkNotLogModifier.Checked && e.IsModifierKey)) { //If checkNoKeyPress is checked, we are not going to make a log for the key press event. if (!checkNoLogKeyPress.Checked) { listLog.Items.Add(Misc.MakeKeyLog(e, Misc.KeyEventType.OnKeyUp)); } } //If checkDisableAltF4 checkbox is checked and we are pressing alt + F4, let our system know that we are handling the input thus disabling it. if (checkDisableAltF4.Checked && (e.Alt != ModifierKeySide.None && e.KeyCode == VirtualKeycodes.F4)) { e.Handled = true; return; } //If checkDisableNotABC checkbox is checked and we are pressing any keys besides A, B and C, let our system know that we are handling the input which in effect disabling it. if (checkDisableNotABC.Checked && (e.KeyCode < VirtualKeycodes.A || e.KeyCode > VirtualKeycodes.C)) { e.Handled = true; return; } }
private void GlobalKeyHook_OnKeyUp(object sender, GlobalKeyEventArgs e) { //Log modifier key up if the checkNotLogModifier checkbox is not checked. if (!(checkNotLogModifier.Checked && e.IsModifierKey)) { if (!checkNoLogKeyUp.Checked) { listLog.Items.Add(Misc.MakeKeyLog(e, Misc.KeyEventType.OnKeyUp)); //Our Helper method MakeKeyLog will make the log text for us. We just need to add it it to listLog. } } //If checkDisableAltF4 checkbox is checked and we released alt + F4, let our system know that we are handling the input thus disabling it. if (checkDisableAltF4.Checked && (e.Alt != ModifierKeySide.None && e.KeyCode == VirtualKeycodes.F4)) { e.Handled = true; return; } //If checkDisableNotABC checkbox is checked and we released any keys besides A, B and C, let our system know that we are handling the input which in effect disabling it. if (checkDisableNotABC.Checked && (e.KeyCode < VirtualKeycodes.A || e.KeyCode > VirtualKeycodes.C)) { e.Handled = true; return; } }
/// <summary> /// Global keyboard shortcut handler. /// </summary> /// <param name="sender">This.</param> /// <param name="e">Event arguments.</param> private void GlobalInput_KeyDown(object sender, GlobalKeyEventArgs e) { if ((e.KeyData & ~Keys.Shift) == (Keys.Control | Keys.Space)) // Ctrl+Space, Shift+Ctrl+Space { e.IsHandled = true; GlobalInput.Paste(NBSP); } }
public static string MakeKeyLog(GlobalKeyEventArgs e, KeyEventType keyEventType) { bool ModifierKeyPressed = false; StringBuilder logMessage = new StringBuilder("Keyboard: "); //Start creating our text switch (keyEventType) //Check which event called this method and set the appropriate text for it. The calling method passed on the event type to us via keyEventType argument. { case KeyEventType.OnKeyDown: logMessage.Append(e.KeyCode + " key has been pressed. "); break; case KeyEventType.OnKeyPress: logMessage.Append(e.KeyCode + " key is still being pressed. "); break; default: logMessage.Append(e.KeyCode + " key has been released. "); break; } //Check if the resulting character is set to something or not (e.g. CharResult would be empty if the user presses Shift on it's own.) if (!string.IsNullOrWhiteSpace(e.CharResult)) { logMessage.Append(" Resulting Character: " + e.CharResult + " -- "); } logMessage.Append("[Modifier Key(s) Pressed: "); //Let's check which modifier keys are being pressed and append it to the log. if (e.Control != ModifierKeySide.None) { ModifierKeyPressed = true; logMessage.Append(e.Control.ToString() + " Control"); } if (e.Shift != ModifierKeySide.None) { logMessage.Append((ModifierKeyPressed ? ", " : "") + e.Shift.ToString() + " Shift"); ModifierKeyPressed = true; } if (e.Alt != ModifierKeySide.None) { logMessage.Append((ModifierKeyPressed ? ", " : "") + e.Alt.ToString() + " Alt"); ModifierKeyPressed = true; } //If no modifier key was pressed, we append 'None' to the log to indicate that there was no modifier key being pressed. if (!ModifierKeyPressed) { logMessage.Append("None"); } logMessage.Append("]"); return(logMessage.ToString()); //Build the log text and return it to the calling method. }
private void OnKeyPressed(Object sender, GlobalKeyEventArgs e) { Int64 now = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeMilliseconds(); if (now - _lastKeyInput < 25) { return; } _lastKeyInput = now; EventsAndGlobalsController.RecognizeInputAndThrowEvent(sender, e); }
/// <summary> /// This method will call the OnKeyUp event exposed from the library and pass on the information about the key that was pressed. /// </summary> /// <param name="e">Argument passed by the KeyboardPressed event found in the internal GlobalKeyboardHook class.</param> /// <returns>Returns true if the event was handled and false if not.</returns> bool KeyUp(GlobalKeyboardHookEventArgs e) { GlobalKeyEventArgs globalKeyEventArgs = new GlobalKeyEventArgs(e, alt, ctrl, shift); EventHandler <GlobalKeyEventArgs> handler = OnKeyUp; if (handler == null) { return(false); } handler(this, globalKeyEventArgs); return(globalKeyEventArgs.Handled); }
/// <summary> /// This method will call the OnKeyPressed event exposed from the library and pass on the information about the key that was pressed. /// </summary> /// <param name="e">Argument passed by the KeyboardPressed event found in the internal GlobalKeyboardHook class.</param> /// <returns>Returns true if the event was handled and false if not.</returns> bool KeyPressed(GlobalKeyboardHookEventArgs e) { GlobalKeyEventArgs globalKeyEventArgs = new GlobalKeyEventArgs(e, alt, ctrl, shift); //Store the information passed to this method by the _OnKeyPressed method. This variable will be passed to the methods subscribed to the OnKeyPressed event. EventHandler <GlobalKeyEventArgs> handler = OnKeyPressed; if (handler == null) //If there's nothing subscribed to the OnKeyPressed event, we exit from the method. { return(false); } handler(this, globalKeyEventArgs); //Call the OnKeyPressed event and pass on the globalKeyEventArgs as an argument return(globalKeyEventArgs.Handled); //Now, we return the bool value of the handled variable back to the _OnKeyPressed method. }
public void GlobalKeyEventArgs_Test() { GlobalKeyEventArgs eventArgs; eventArgs = new GlobalKeyEventArgs(Key.A, KeyAction.Down); Assert.AreEqual("<A>: Down", eventArgs.ToString()); eventArgs = new GlobalKeyEventArgs(Key.A, KeyAction.Up); Assert.AreEqual("<A>: Up", eventArgs.ToString()); eventArgs = new GlobalKeyEventArgs(Key.A, KeyAction.Pressed); Assert.AreEqual("<A>: Pressed", eventArgs.ToString()); }
private void OnGlobalHotkeyDown(object sender, GlobalKeyEventArgs e) { var hotKey = e.HotKey; if (hotKey.Equals(CopyToClipboardHotkey)) { PendingGlobalCommand = CopyToClipboardCommand; } else if (hotKey.Equals(CompileHotkey)) { PendingGlobalCommand = CompileCommand; } else if (hotKey.Equals(CompileAndRunHotkey)) { PendingGlobalCommand = CompileAndRunCommand; } }
private void GlobalKeyHook_OnKeyDown(object sender, GlobalKeyEventArgs e) { foreach (var bind in Keybindings.binds) { bool caprequired = false; if (Keybindings.ToggleOnCaps == true && Console.CapsLock) { caprequired = true; } else if (Keybindings.ToggleOnCaps == false) { caprequired = true; } if (bind.Value == e.KeyCode && caprequired) { if (OutputDevice.PlaybackState == PlaybackState.Playing) { OutputDevice.Stop(); } var AudioFile = new AudioFileReader(bind.Key); OutputDevice.Init(AudioFile); OutputDevice.Play(); return; } } if (e.Alt != ModifierKeySide.None && e.KeyCode == VirtualKeycodes.B) { Random rand = new Random(); rand.Next(); var b = audioFiles[rand.Next(0, audioFiles.Count)]; var AudioFile = new AudioFileReader(b); if (OutputDevice.PlaybackState == PlaybackState.Playing) { OutputDevice.Stop(); } OutputDevice.Init(AudioFile); OutputDevice.Play(); e.Handled = true; return; } }
private async void GlobalKeyHook_OnKeyDown(object sender, GlobalKeyEventArgs e) { tempKey = e.KeyCode; if (e.KeyCode.ToString() == textBox_AzureKeySettingSpeech.Text) { try { SendKeys.Send(await azure.MicrophoneInput(Form1.e_selectionLanguage)); } catch (System.ApplicationException) { printLog(CAzureError.micNotRecognize); } } else if (e.KeyCode.ToString() == textBox_AzureKeySettingToggle.Text) { toogleState = e_currentToggleState.OFF; btn_AzureOff_Click(this, null); } }
internal static void RecognizeInputAndThrowEvent(Object sender, GlobalKeyEventArgs e) { Boolean isNeedRedraw = false; if (e.Control == ModifierKeySide.None) { return; } e.Handled = true; switch (e.KeyCode) { case ChangeWeaponMenuState: ChangedWeaponMenuState?.Invoke(sender, e); break; case ChangeSightPosition: { if (!CheckLastRedrawTime(50)) { return; } ChangedSightPosition?.Invoke(Utils.GetCursorPosition(RenderTargetSize)); isNeedRedraw = true; break; } default: e.Handled = false; break; } if (!isNeedRedraw) { return; } NeedRedraw?.Invoke(); }
private static void GlobalKeyHook_OnKeyDown(object sender, GlobalKeyEventArgs e) { Console.WriteLine("KeyDown " + e.CharResult); }
private static void GlobalKeyHook_OnKeyUp(object sender, GlobalKeyEventArgs e) { Console.WriteLine("Released " + e.CharResult); }
private void WindowKeyUp(object sender, GlobalKeyEventArgs e) { _isPressCtrl = e.IsPressCtrl; _isPressShift = e.IsPressShift; }
private void GlobalKeyHook_OnKeyDown(object sender, GlobalKeyEventArgs e) { returnValue = e.KeyCode; globalKeyHook.Dispose(); this.Close(); }
private async void WindowKeyDown(object sender, GlobalKeyEventArgs e) { _isPressCtrl = e.IsPressCtrl; _isPressShift = e.IsPressShift; if (e.IsPressCtrl) { switch (e.Key) { case VirtualKey.Z: if (_viewModel.CanUndo) { _viewModel.Undo(1); } break; case VirtualKey.Y: if (_viewModel.CanRedo) { _viewModel.Redo(1); } break; } } if (!e.IsInputing) { switch (e.Key) { case VirtualKey.I: LyricsContent_TextBox.Focus(FocusState.Keyboard); break; case VirtualKey.Space: Focus(FocusState.Pointer); if (Lyrics_ListView.SelectedItems.Any()) { _viewModel.Move(Player.Position); Lyrics_ListView.SelectedIndex = Lyrics_ListView.SelectedIndex < Lyrics_ListView.Items.Count - 1 ? Lyrics_ListView.SelectedIndex + 1 : -1; } else { AddLyrics(); } break; case VirtualKey.C: _viewModel.Copy(Player.Position); break; case VirtualKey.Delete: int selectedId = Lyrics_ListView.SelectedIndex; _viewModel.Remove(); if (selectedId < Lyrics_ListView.Items.Count) { Lyrics_ListView.SelectedIndex = selectedId; } break; case VirtualKey.M: if (Lyrics_ListView.SelectedItem is Lyric) { InputSubmitOperations_ComboBox.SelectedIndex = 1; LyricsContent_TextBox.Focus(FocusState.Keyboard); } break; case VirtualKey.S: _viewModel.Sort(_viewModel.LyricItems); break; case VirtualKey.G: if (Lyrics_ListView.SelectedItem is Lyric lyric) { GoToLyricTime(lyric); } break; case VirtualKey.Up: Focus(FocusState.Pointer); if (!_lyricsListGotFocus) { Lyrics_ListView.SelectedIndex = Lyrics_ListView.SelectedIndex > -1 ? Lyrics_ListView.SelectedIndex - 1 : Lyrics_ListView.Items.Count - 1; } break; case VirtualKey.Down: Focus(FocusState.Pointer); if (!_lyricsListGotFocus) { Lyrics_ListView.SelectedIndex = Lyrics_ListView.SelectedIndex < Lyrics_ListView.Items.Count - 1 ? Lyrics_ListView.SelectedIndex + 1 : -1; } break; } } switch (e.Key) { case VirtualKey.Escape: this.Focus(FocusState.Pointer); break; case VirtualKey.I: if (_isPressCtrl) { await LyricsFileInfo_ContentDialog.ShowAsync(); } break; } }