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