/// <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(Program.SysConfig.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 (Program.SysConfig.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 = Program.SysConfig.LocalHotKeyContainer.Exists
(
delegate(LocalHotKey f)
{
return(f.Key == hotKey.BaseKey && f.Modifier == hotKey.BaseModifier);
}
);
if (Program.SysConfig.ChordHotKeyContainer.Contains(hotKey) || LocalExists)
{
if (!this.SuppressException)
{
throw new HotKeyAlreadyRegisteredException("HotKey already registered!", hotKey);
}
return(false);
}
Program.SysConfig.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 = Program.SysConfig.LocalHotKeyContainer.Find
(
delegate(LocalHotKey l)
{
return(l.Name == name);
}
);
if (local != null)
{
return(true);
}
ChordHotKey chord = Program.SysConfig.ChordHotKeyContainer.Find
(
delegate(ChordHotKey c)
{
return(c.Name == name);
}
);
if (chord != null)
{
return(true);
}
GlobalHotKey global = Program.SysConfig.GlobalHotKeyContainer.Find
(
delegate(GlobalHotKey g)
{
return(g.Name == name);
}
);
if (global != null)
{
return(true);
}
return(false);
}
public ChordHotKeyEventArgs(ChordHotKey hotkey)
{
HotKey = hotkey;
}
public HotKeyAlreadyRegisteredException(string message, ChordHotKey hotKey, Exception inner) : base(message, inner)
{
ChordKey = hotKey;
}
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 = Program.SysConfig.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 = Program.SysConfig.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 = Program.SysConfig.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 = Program.SysConfig.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 = Program.SysConfig.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);
}
}
/// <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);
}