public static void ProcessMouseHotkeys() { CheckCurrentHotkey(); foreach (var pair in Handlers) { var bind = CheckInternal(pair.Key, true); if (bind != null && bind.UsesMouse) { var handler = pair.Value; if (handler.condition()) { bool waspressed = CheckPressed( bind, ref _prev_kbstate, ref _prev_mousestate); if (waspressed) { continue; } _current_hotkey?.keyuphandler?.Invoke(); _current_hotkey = handler; handler.keydownhandler(); break; } } } }
public Hotkey(Keys key, Modifiers modifiers, HotkeyHandler handler) { Key = key; Modifiers = modifiers; Handler = handler; Id = GetHashCode(); }
public static void ProcessKeyboardHotkeys() { if (CheckCurrentHotkey()) { var kb = CheckInternal(_current_hotkey.hotkey, true); if (!kb.UsesMouse && _current_hotkey.repeat) { _current_hotkey.keydownhandler(); } return; } _current_hotkey = null; foreach (var pair in Handlers) { var bind = CheckInternal(pair.Key, false); if (bind != null) { var handler = pair.Value; if (handler.condition()) { bool waspressed = CheckPressed( bind, ref _prev_kbstate, ref _prev_mousestate); if (waspressed && !handler.repeat) { continue; } handler.keydownhandler(); _current_hotkey = handler; break; } } } }
/// <summary> /// Handle configuration changed /// - apply changes as needed /// - Send telemetry /// </summary> /// <param name="testconfig"></param> internal void HandleConfigurationChanged(IReadOnlyDictionary <string, object> changes) { HotkeyHandler?.Dispose(); InitHotKeys(); var configManager = ConfigurationManager.GetDefaultInstance(); SelectAction.GetDefaultInstance().IntervalMouseSelector = configManager.AppConfig.MouseSelectionDelayMilliSeconds; this.Topmost = configManager.AppConfig.AlwaysOnTop; this.ctrlTestMode.ctrlTabStop.SetHotkeyText(configManager.AppConfig.HotKeyForRecord); HighlightAction.GetDefaultInstance().HighlighterMode = configManager.AppConfig.HighlighterMode; configManager.TestConfig = TestSetting.GenerateSuiteConfiguration(RuleSelection.SuiteConfigurationType.Default); InitSelectActionMode(); HideConfigurationMode(); if (changes != null && changes.ContainsKey(ConfigurationModel.keyFontSize)) { SetFontSize(); } UpdateMainWindowUI(); this.btnConfig.Focus(); }
protected override void OnClosed(EventArgs e) { _source.RemoveHook(HotkeyHandler.HwndHook); _source = null; HotkeyHandler.UnregisterHotKey(this); base.OnClosed(e); }
public Hotkey(Keys key, Modifiers modifiers, HotkeyHandler handler) { Key = key; Modifiers = modifiers; Handler = handler; Id = GetHashCode(); }
public static bool Register(IntPtr hwnd, Modifier modifier, Keys key, HotkeyHandler callback) { bool b = RegisterHotKey(hwnd, ++_idCount, (uint)modifier, (uint)key); _callbacks.Add(_idCount, callback); return(b); }
private void Update() { OnFirstRun(); if (MainMenuController.MainMenuActive) { return; } if (_lastAutoSave == null) { // make the first autosave actually happen 5 mins after the game starts not on the first call _lastAutoSave = DateTime.Now; } else if ((DateTime.Now - _lastAutoSave.Value).TotalSeconds > 600) { // autosave every two minutes _lastAutoSave = DateTime.Now; SaveManager.SaveGame(); } HotkeyHandler.HandleHotkeys(); DestroyItemsInCache(); }
public static void Unregister(IntPtr hwnd, HotkeyHandler callback) { var item = _callbacks.FirstOrDefault(cb => cb.Value == callback); if (!item.Equals(default(KeyValuePair <int, HotkeyHandler>))) { UnregisterHotKey(hwnd, item.Key); _callbacks.Remove(item.Key); } }
public void FireHotkeyPressed(int id) { HotkeyHandler hotkeyPressed = this.HotkeyPressed; if (hotkeyPressed == null) { return; } hotkeyPressed(id); }
/// <summary> /// Registers the hotkey with the manager. /// </summary> /// <param name="alias"></param> /// <param name="keys"></param> /// <param name="handler"></param> /// <returns></returns> public static bool Register(string alias, List<Keys> keys, HotkeyHandler<System.EventArgs> handler) { // Ensure this hotkey doesn't exist.. if (_hotkeys.Any(h => h.Alias == alias.ToLower())) return false; // Insert the new hotkey.. _hotkeys.Add(new Hotkey(alias, keys, handler)); return true; }
protected override void OnSourceInitialized(EventArgs e) { base.OnSourceInitialized(e); IntPtr handle = new WindowInteropHelper(this).Handle; _source = HwndSource.FromHwnd(handle); _source.AddHook(HotkeyHandler.HwndHook); HotkeyHandler.RegisterHotKey(this); }
public static void ProcessKeyup() { if (_current_hotkey != null) { if (!Check(_current_hotkey.hotkey)) { _current_hotkey.keyuphandler?.Invoke(); _current_hotkey = null; } } }
public Hotkey(KeyGesture keyGesture, string description, MyAction action, HotkeyGroup group, HotkeyHandler handler) { KeyGesture = keyGesture; Description = description; Action = action; Group = group; Handler = handler; int virtualKeyCode = KeyInterop.VirtualKeyFromKey(KeyGesture.Key); Id = virtualKeyCode + ((int)KeyGesture.Modifiers * 0x10000); }
/// <summary> /// Registers the hotkey with the manager. /// </summary> /// <param name="alias"></param> /// <param name="keys"></param> /// <param name="handler"></param> /// <returns></returns> public static bool Register(string alias, List <Keys> keys, HotkeyHandler <System.EventArgs> handler) { // Ensure this hotkey doesn't exist.. if (_hotkeys.Any(h => h.Alias == alias.ToLower())) { return(false); } // Insert the new hotkey.. _hotkeys.Add(new Hotkey(alias, keys, handler)); return(true); }
public HotkeyHandle Map(Hotkey hotkey, HotkeyHandler action) { var mapping = new HotkeyMapping { Hotkey = hotkey, Action = action, Id = Interlocked.Increment(ref _idCounter) }; _agent.AddMapping(mapping); return HotkeyHandle.Create(() => _agent.RemoveMappingByHotkey(hotkey)); }
public override void KeyReleased(KeyPayload payload) { if (settings.MicType == MicTypeEnum.PTT) { VMManager.Instance.SetParam(BuildDeviceName(), 1); if (!String.IsNullOrEmpty(settings.MuteHotkey)) { HotkeyHandler.RunHotkey(settings.MuteHotkey); } } }
public override void KeyPressed(KeyPayload payload) { // Used for long press //keyPressStart = DateTime.Now; //keyPressed = true; List <int> eList = JsonFiles.LoadJSONList("EntryList"); SelectedCars = JsonFiles.LoadJSONList("Selected"); string hotkey = "Numpad"; string value = ""; int carNum = 0; if (eList != null && eList.Count > 0 && settings.CarPosition > 0 && settings.CarPosition <= eList.Count) { value = eList[settings.CarPosition - 1].ToString(); } for (int i = 0; i < value.Length; i++) { HotkeyHandler.RunHotkey("{" + hotkey + value[i] + "}"); } Int32.TryParse(value, out carNum); if (carNum > 0) { bool isSel = false; foreach (var l in SelectedCars) { if (l == carNum) { isSel = true; break; } } HotkeyHandler.RunHotkey("{Multiply}"); if (!isSel) { HotkeyHandler.RunHotkey("{Add}"); SelectedCars.Add(carNum); } else { HotkeyHandler.RunHotkey("{Subtract}"); SelectedCars.Remove(carNum); } JsonFiles.SaveJSONList("Selected", SelectedCars); } Logger.Instance.LogMessage(TracingLevel.INFO, "Key Pressed"); }
public static bool Invoke(KeyGesture keyGesture, HotkeyHandler handler) { foreach (var hk in HotkeyMap) { var kg = hk.Value.KeyGesture; if (kg.Key == keyGesture.Key && kg.Modifiers == keyGesture.Modifiers && handler == hk.Value.Handler) { return(hk.Value.Invoke()); } } return(false); }
public override void KeyReleased(KeyPayload payload) { if (!String.IsNullOrEmpty(settings.KeyReleaseValue)) { VMManager.Instance.SetParameters(settings.KeyReleaseValue); } MidiCommandHandler.HandleMidiParameters(settings.ReleaseMidi); if (!String.IsNullOrEmpty(settings.ReleaseHotkey)) { HotkeyHandler.RunHotkey(settings.ReleaseHotkey); } }
public HotkeySettings() { InitializeComponent(); saveBuffer.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.SaveBuffer); startBuffer.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.StartBuffer); stopBuffer.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.StopBuffer); toggleBuffer.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.ToggleBuffer); startRecording.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.StartRecording); stopRecording.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.StopRecording); toggleRecording.Config = HotkeyHandler.GetHotkey(Configuration.HotkeyType.ToggleRecording); }
/// <inheritdoc /> public void RegisterHotkey(Hotkey hotkey, HotkeyHandler handler) { var vk = KeyInterop.VirtualKeyFromKey((Key)hotkey.Key); var mods = hotkey.Modifiers; var id = (vk << 8) | mods; if (!NativeMethods.RegisterHotKey(_sponge.Handle, id, mods, vk)) { Debug.WriteLine("Could not register a hotkey", GetType().Name); return; } _hotkeyHandlerDic.Add(id, handler); }
public static KeyboardState RemoveHotkeys(this KeyboardState self) { List <Keys> keys = new List <Keys>(); foreach (Keys key in self.GetPressedKeys()) { if (!HotkeyHandler.IsHotkey(key)) { keys.Add(key); } } return(new KeyboardState(keys.ToArray())); }
private void InitializeSettings() { string mode1Hotkey = HotkeyHandler.ParseKeystroke(settings.Mode1Hotkey); string mode2Hotkey = HotkeyHandler.ParseKeystroke(settings.Mode2Hotkey); // If the parsed hotkey is different than what the user inputed, overwrite the user input // because it's invalid if (mode1Hotkey != settings.Mode1Hotkey || mode2Hotkey != settings.Mode2Hotkey) { settings.Mode1Hotkey = mode1Hotkey; settings.Mode2Hotkey = mode2Hotkey; SaveSettings(); } }
private void InitializeSettings() { string keypressHotkey = HotkeyHandler.ParseKeystroke(settings.KeypressHotkey); string releaseHotkey = HotkeyHandler.ParseKeystroke(settings.ReleaseHotkey); // If the parsed hotkey is different than what the user inputed, overwrite the user input // because it's invalid if (keypressHotkey != settings.KeypressHotkey || releaseHotkey != settings.ReleaseHotkey) { settings.KeypressHotkey = keypressHotkey; settings.ReleaseHotkey = releaseHotkey; SaveSettings(); } }
/// <summary> /// Checks if the currently pressed hotkey is still 'pressed' after a /// state change. /// </summary> public static bool CheckCurrentHotkey() { if (_current_hotkey != null) { if (Check(_current_hotkey.hotkey) && _current_hotkey.condition()) { return(true); } _current_hotkey.keyuphandler?.Invoke(); _current_hotkey = null; } return(false); }
public void LongKeyPressed() { longKeyPressed = true; if (!String.IsNullOrEmpty(settings.LongPressValue)) { VMManager.Instance.SetParameters(settings.LongPressValue); } MidiCommandHandler.HandleMidiParameters(settings.LongMidi); if (!String.IsNullOrEmpty(settings.LongHotkey)) { HotkeyHandler.RunHotkey(settings.LongHotkey); } }
public async override void KeyPressed(KeyPayload payload) { Logger.Instance.LogMessage(TracingLevel.INFO, $"{this.GetType()} KeyPressed"); if (!VMManager.Instance.IsConnected) { Logger.Instance.LogMessage(TracingLevel.ERROR, $"Key pressed but VM is not connected!"); await Connection.ShowAlert(); return; } bool triggeredMute = false; switch (settings.MicType) { case MicTypeEnum.SingleMode: int value; if (Int32.TryParse(settings.SingleValue, out value)) { VMManager.Instance.SetParam(BuildDeviceName(), value); triggeredMute = value != 0; } else { await Connection.ShowAlert(); } break; case MicTypeEnum.Toggle: bool isMuted = VMManager.Instance.GetParamBool(BuildDeviceName()); VMManager.Instance.SetParam(BuildDeviceName(), isMuted ? 0 : 1); triggeredMute = !isMuted; break; case MicTypeEnum.PTT: VMManager.Instance.SetParam(BuildDeviceName(), 0); triggeredMute = false; break; } if (triggeredMute && !String.IsNullOrEmpty(settings.MuteHotkey)) { HotkeyHandler.RunHotkey(settings.MuteHotkey); } else if (!triggeredMute && !String.IsNullOrEmpty(settings.UnmuteHotkey)) { HotkeyHandler.RunHotkey(settings.UnmuteHotkey); } }
public override void KeyReleased(KeyPayload payload) { keyPressed = false; tmrRunLongPress.Stop(); if (!longKeyPressed && !String.IsNullOrEmpty(settings.SetValue)) { VMManager.Instance.SetParameters(settings.SetValue); MidiCommandHandler.HandleMidiParameters(settings.KeypressMidi); if (!String.IsNullOrEmpty(settings.KeypressHotkey)) { HotkeyHandler.RunHotkey(settings.KeypressHotkey); } } }
public void LongKeyPressed() { longKeyPressed = true; Logger.Instance.LogMessage(TracingLevel.INFO, $"Long keypress"); if (!String.IsNullOrEmpty(settings.LongPressValue)) { VMManager.Instance.SetParameters(settings.LongPressValue); } MidiCommandHandler.HandleMidiParameters(settings.LongMidi); if (!String.IsNullOrEmpty(settings.LongHotkey)) { HotkeyHandler.RunHotkey(settings.LongHotkey); } }
public override void KeyReleased(KeyPayload payload) { tmrRunLongPress.Stop(); if (!longKeyPressed && !String.IsNullOrEmpty(settings.SetValue)) { Logger.Instance.LogMessage(TracingLevel.INFO, $"Short keypress"); VMManager.Instance.SetParameters(settings.SetValue); MidiCommandHandler.HandleMidiParameters(settings.KeypressMidi); if (!String.IsNullOrEmpty(settings.KeypressHotkey)) { HotkeyHandler.RunHotkey(settings.KeypressHotkey); } } }
private void HandleHotkey(KeyEventArgs e, HotkeyHandler handler) { if (e.IsRepeat) { return; } try { KeyGesture gesture = new KeyGesture(e.Key, Keyboard.Modifiers); e.Handled = Hotkey.Invoke(gesture, handler); } catch (Exception ex) { LogManager.Instance.Error(this, ex.ToString()); } }
private void HotKeyHandler_Tick(object sender, EventArgs e) { var now = DateTime.Now; //we can be super responsive when someone is tapping +- while not accidentally moving it up or down twice by doing manual checks while having the timer at ~5-10ms if (_lastHotkey == null) { _lastHotkey = now; } else if ((now - _lastHotkey).TotalMilliseconds < 100) { return; } var modifier = (Keys)0; var fogModifier = (Keys)0; var up = (Keys)0; var toggleFog = (Keys)0; var down = (Keys)0; TryParseKeys(settings.HotKeyModifier, ref modifier); TryParseKeys(settings.HotKeyFogModifier, ref fogModifier); TryParseKeys(settings.HotKeyUp, ref up); TryParseKeys(settings.HotKeyFog, ref toggleFog); TryParseKeys(settings.HotKeyDown, ref down); if (HotkeyHandler.IsKeyPushedDown(modifier)) { if (HotkeyHandler.IsKeyPushedDown(up)) { SetFoVNumeric(FoVNumeric.Value + 1); _lastHotkey = now; } if (HotkeyHandler.IsKeyPushedDown(down)) { SetFoVNumeric(FoVNumeric.Value - 1); _lastHotkey = now; } } if (HotkeyHandler.IsKeyPushedDown(fogModifier) && HotkeyHandler.IsKeyPushedDown(toggleFog)) { FogCheckBox.Checked = !FogCheckBox.Checked; _lastHotkey = now; } }
/// <summary> /// Default Constructor /// </summary> /// <param name="alias"></param> /// <param name="keys"></param> /// <param name="handler"></param> public Hotkey(string alias, List<Keys> keys, HotkeyHandler<System.EventArgs> handler) { this.Alias = alias; this.Keys = keys; this.Handler = handler; }
public void RegisterHotkey(Keys hotkey) { if (this._hotkeyHandler != null) { this.UnregisterHotkey(); } if (hotkey == Keys.None) { return; } this._hotkeyHandler = new HotkeyHandler(this.Handle, hotkey); this._hotkeyHandler.Pressed += HotkeyPressed_Handler; try { this._hotkeyHandler.Register(); System.Diagnostics.Debug.WriteLine("Registered shortcut for " + this.Title); } catch (Exception) { System.Diagnostics.Debug.WriteLine("Failed to register shortcut for " + this.Title); // There can be a lot of possible exception reasons here // In case of any of them the hotkey setting is silently ignored } }
public void UnregisterHotkey() { if (this._hotkeyHandler == null) { return; } this._hotkeyHandler.Unregister(); this._hotkeyHandler.Pressed -= HotkeyPressed_Handler; this._hotkeyHandler.Dispose(); this._hotkeyHandler = null; }