/// <summary>Checks if a ChordHotKey has been registered. /// </summary> /// <param name="chordhotkey">The ChordHotKey to check.</param> /// <returns>True if the ChordHotKey has been registered, false otherwise.</returns> public bool HotKeyExists(ChordHotKey chordhotkey) { return(ChordHotKeyContainer.Exists ( delegate(ChordHotKey c) { return (c == chordhotkey); } )); }
/// <summary>Unregisters a ChordHotKey. /// </summary> /// <param name="hotKey">The hotKey to be removed</param> /// <returns>True if success, otherwise false</returns> public bool RemoveChordHotKey(ChordHotKey hotKey) { if (ChordHotKeyContainer.Remove(hotKey) == true) { --ChordHotKeyCount; return(true); } else { return(false); } }
//Override .Equals(object) public override bool Equals(object obj) { LocalHotKey hotKey = obj as LocalHotKey; if (hotKey != null) { return(Equals(hotKey)); } ChordHotKey chotKey = obj as ChordHotKey; if (chotKey != null) { return(Equals(chotKey)); } return(false); }
/// <summary>Registers a ChordHotKey. /// </summary> /// <param name="hotKey">The hotKey which will be added. Must not be null and can be registered only once.</param> /// <returns>True if registered successfully, false otherwise.</returns> /// <exception cref="HotKeyAlreadyRegisteredException">thrown if a LocalHotkey with the same name and or key and modifier has already been added.</exception> public bool AddChordHotKey(ChordHotKey hotKey) { if (hotKey == null) { if (!this.SuppressException) { throw new ArgumentNullException("value"); } return(false); } if (hotKey.BaseKey == 0 || hotKey.ChordKey == 0) { if (!this.SuppressException) { throw new ArgumentNullException("value.Key"); } return(false); } //Check if a LocalHotKey already has its Key and Modifier. bool LocalExists = LocalHotKeyContainer.Exists ( delegate(LocalHotKey f) { return(f.Key == hotKey.BaseKey && f.Modifier == hotKey.BaseModifier); } ); if (ChordHotKeyContainer.Contains(hotKey) || LocalExists) { if (!this.SuppressException) { throw new HotKeyAlreadyRegisteredException("HotKey already registered!", hotKey); } return(false); } ChordHotKeyContainer.Add(hotKey); ++ChordHotKeyCount; return(true); }
/// <summary>Checks if a HotKey has been registered. /// </summary> /// <param name="name">The name of the HotKey.</param> /// <returns>True if the HotKey has been registered, false otherwise.</returns> public bool HotKeyExists(string name) { LocalHotKey local = LocalHotKeyContainer.Find ( delegate(LocalHotKey l) { return(l.Name == name); } ); if (local != null) { return(true); } ChordHotKey chord = ChordHotKeyContainer.Find ( delegate(ChordHotKey c) { return(c.Name == name); } ); if (chord != null) { return(true); } GlobalHotKey global = GlobalHotKeyContainer.Find ( delegate(GlobalHotKey g) { return(g.Name == name); } ); if (global != null) { return(true); } return(false); }
/// <summary>Removes the hotkey(Local, Chord or Global) with the specified name. /// </summary> /// <param name="name">The name of the hotkey.</param> /// <returns>True if successful and false otherwise.</returns> public bool RemoveHotKey(string name) { LocalHotKey local = LocalHotKeyContainer.Find ( delegate(LocalHotKey l) { return(l.Name == name); } ); if (local != null) { return(RemoveLocalHotKey(local)); } ChordHotKey chord = ChordHotKeyContainer.Find ( delegate(ChordHotKey c) { return(c.Name == name); } ); if (chord != null) { return(RemoveChordHotKey(chord)); } GlobalHotKey global = GlobalHotKeyContainer.Find ( delegate(GlobalHotKey g) { return(g.Name == name); } ); if (global != null) { return(RemoveGlobalHotKey(global)); } return(false); }
public bool PreFilterMessage(ref Message m) { if (!Enabled) { return(false); } //Check if the form that the HotKeyManager is registered to is inactive. if (DisableOnManagerFormInactive) { if (Form.ActiveForm != null && this.ManagerForm != Form.ActiveForm) { return(false); } } //For LocalHotKeys, determine if modifiers Alt, Shift and Control is pressed. Microsoft.VisualBasic.Devices.Keyboard UserKeyBoard = new Microsoft.VisualBasic.Devices.Keyboard(); bool AltPressed = UserKeyBoard.AltKeyDown; bool ControlPressed = UserKeyBoard.CtrlKeyDown; bool ShiftPressed = UserKeyBoard.ShiftKeyDown; Modifiers LocalModifier = Modifiers.None; if (AltPressed) { LocalModifier = Modifiers.Alt; } if (ControlPressed) { LocalModifier |= Modifiers.Control; } if (ShiftPressed) { LocalModifier |= Modifiers.Shift; } switch ((KeyboardMessages)m.Msg) { case (KeyboardMessages.WmSyskeydown): case (KeyboardMessages.WmKeydown): Keys keydownCode = (Keys)(int)m.WParam & Keys.KeyCode; if (KeyPressEvent != null) { KeyPressEvent(this, new HotKeyEventArgs(keydownCode, LocalModifier, RaiseLocalEvent.OnKeyDown)); } //Check if a chord has started. if (InChordMode) { //Check if the Key down is a modifier, we'll have to wait for a real key. switch (keydownCode) { case Keys.Control: case Keys.ControlKey: case Keys.LControlKey: case Keys.RControlKey: case Keys.Shift: case Keys.ShiftKey: case Keys.LShiftKey: case Keys.RShiftKey: case Keys.Alt: case Keys.Menu: case Keys.LMenu: case Keys.RMenu: case Keys.LWin: return(true); } ChordHotKey ChordMain = ChordHotKeyContainer.Find ( delegate(ChordHotKey cm) { return((cm.BaseKey == PreChordKey) && (cm.BaseModifier == PreChordModifier) && (cm.ChordKey == keydownCode) && (cm.ChordModifier == LocalModifier)); } ); if (ChordMain != null) { ChordMain.RaiseOnHotKeyPressed(); if (ChordPressed != null && ChordMain.Enabled == true) { ChordPressed(this, new ChordHotKeyEventArgs(ChordMain)); } InChordMode = false; return(true); } InChordMode = false; new Microsoft.VisualBasic.Devices.Computer().Audio.PlaySystemSound(System.Media.SystemSounds.Exclamation); return(true); } //Check for a LocalHotKey. LocalHotKey KeyDownHotkey = LocalHotKeyContainer.Find ( delegate(LocalHotKey d) { return((d.Key == keydownCode) && (d.Modifier == LocalModifier) && (d.WhenToRaise == RaiseLocalEvent.OnKeyDown)); } ); if (KeyDownHotkey != null) { KeyDownHotkey.RaiseOnHotKeyPressed(); if (LocalHotKeyPressed != null && KeyDownHotkey.Enabled == true) { LocalHotKeyPressed(this, new LocalHotKeyEventArgs(KeyDownHotkey)); } return(KeyDownHotkey.SuppressKeyPress); } //Check for ChordHotKeys. ChordHotKey ChordBase = ChordHotKeyContainer.Find ( delegate(ChordHotKey c) { return((c.BaseKey == keydownCode) && (c.BaseModifier == LocalModifier)); } ); if (ChordBase != null) { PreChordKey = ChordBase.BaseKey; PreChordModifier = ChordBase.BaseModifier; var e = new PreChordHotKeyEventArgs(new LocalHotKey(ChordBase.Name, ChordBase.BaseModifier, ChordBase.BaseKey)); if (ChordStarted != null) { ChordStarted(this, e); } InChordMode = !e.HandleChord; return(true); } InChordMode = false; return(false); case (KeyboardMessages.WmSyskeyup): case (KeyboardMessages.WmKeyup): Keys keyupCode = (Keys)(int)m.WParam & Keys.KeyCode; if (KeyPressEvent != null) { KeyPressEvent(this, new HotKeyEventArgs(keyupCode, LocalModifier, RaiseLocalEvent.OnKeyDown)); } LocalHotKey KeyUpHotkey = LocalHotKeyContainer.Find ( delegate(LocalHotKey u) { return((u.Key == keyupCode) && (u.Modifier == LocalModifier) && (u.WhenToRaise == RaiseLocalEvent.OnKeyUp)); } ); if (KeyUpHotkey != null) { KeyUpHotkey.RaiseOnHotKeyPressed(); if (LocalHotKeyPressed != null && KeyUpHotkey.Enabled == true) { LocalHotKeyPressed(this, new LocalHotKeyEventArgs(KeyUpHotkey)); } return(KeyUpHotkey.SuppressKeyPress); } return(false); case (KeyboardMessages.WmHotKey): //var lpInt = (int)m.LParam; //Keys Key = (Keys)((lpInt >> 16) & 0xFFFF); //Modifiers modifier = (Modifiers)(lpInt & 0xFFFF); int Id = (int)m.WParam; GlobalHotKey Pressed = GlobalHotKeyContainer.Find ( delegate(GlobalHotKey g) { return((g.Id == (int)Id)); } ); Pressed.RaiseOnHotKeyPressed(); if (GlobalHotKeyPressed != null) { GlobalHotKeyPressed(this, new GlobalHotKeyEventArgs(Pressed)); } return(true); default: return(false); } }
public HotKeyAlreadyRegisteredException(string message, ChordHotKey hotKey, Exception inner) : base(message, inner) { ChordKey = hotKey; }
/// <summary>Compares a LocalHotKey to a ChordHotKey. /// </summary> /// <param name="other">The ChordHotKey to compare.</param> /// <returns>True if equal, false otherwise.</returns> public bool Equals(ChordHotKey other) { return(Key == other.BaseKey && Modifier == other.BaseModifier); }
public ChordHotKeyEventArgs(ChordHotKey hotkey) { HotKey = hotkey; }