/// <summary>
/// 注册热键
/// </summary>
/// <param name="handle"></param>
/// <param name="id"></param>
/// <param name="key"></param>
/// <param name="modifiers"></param>
/// <returns></returns>
public static bool RegisterHotKey(IntPtr handle, int id, EasyModifierKeys modifiers, EasyKey key)
{
var virtualCode = EasyKeyInterop.VirtualKeyFromKey(key);
var modifiersKey = (uint)modifiers;
return(RegisterHotKey(handle, id, modifiersKey, (uint)virtualCode));
}
public HotKey Register(EasyKey key, EasyModifierKeys modifiers)
{
var hotKey = new HotKey(key, modifiers);
Register(hotKey);
return(hotKey);
}
/// <summary>
/// ConvertTo()
/// </summary>
/// <param name="context"></param>
/// <param name="culture"></param>
/// <param name="value"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
/// <ExternalAPI/>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (destinationType == typeof(string))
{
EasyModifierKeys modifiers = (EasyModifierKeys)value;
if (!IsDefinedModifierKeys(modifiers))
{
throw new InvalidEnumArgumentException("value", (int)modifiers, typeof(EasyModifierKeys));
}
else
{
string strModifiers = "";
if ((modifiers & EasyModifierKeys.Control) == EasyModifierKeys.Control)
{
strModifiers += MatchModifiers(EasyModifierKeys.Control);
}
if ((modifiers & EasyModifierKeys.Alt) == EasyModifierKeys.Alt)
{
if (strModifiers.Length > 0)
{
strModifiers += Modifier_Delimiter;
}
strModifiers += MatchModifiers(EasyModifierKeys.Alt);
}
if ((modifiers & EasyModifierKeys.Windows) == EasyModifierKeys.Windows)
{
if (strModifiers.Length > 0)
{
strModifiers += Modifier_Delimiter;
}
strModifiers += MatchModifiers(EasyModifierKeys.Windows);;
}
if ((modifiers & EasyModifierKeys.Shift) == EasyModifierKeys.Shift)
{
if (strModifiers.Length > 0)
{
strModifiers += Modifier_Delimiter;
}
strModifiers += MatchModifiers(EasyModifierKeys.Shift);;
}
return(strModifiers);
}
}
throw GetConvertToException(value, destinationType);
}
/// <summary>
/// ConvertFrom()
/// </summary>
/// <param name="context"></param>
/// <param name="culture"></param>
/// <param name="source"></param>
/// <returns></returns>
/// <ExternalAPI/>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object source)
{
if (source is string)
{
string modifiersToken = ((string)source).Trim();
EasyModifierKeys modifiers = GetModifierKeys(modifiersToken, CultureInfo.InvariantCulture);
return(modifiers);
}
throw GetConvertFromException(source);
}
/// <summary>
/// 是否是Ctrl、Alt、Shift
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
private bool TryGetModifierKey(EasyKey key, out EasyModifierKeys modifierKeys)
{
modifierKeys = EasyModifierKeys.None;
bool hasFlag = false;
if (hasFlag = _keyMap.ContainsKey(key))
{
modifierKeys = _keyMap[key];
}
return(hasFlag);
}
private EasyModifierKeys GetModifierKeys(string modifiersToken, CultureInfo culture)
{
EasyModifierKeys modifiers = EasyModifierKeys.None;
if (modifiersToken.Length != 0)
{
int offset = 0;
do
{
offset = modifiersToken.IndexOf(Modifier_Delimiter);
string token = (offset < 0) ? modifiersToken : modifiersToken.Substring(0, offset);
token = token.Trim();
token = token.ToUpper(culture);
if (token == String.Empty)
{
break;
}
switch (token)
{
case "CONTROL":
case "CTRL":
modifiers |= EasyModifierKeys.Control;
break;
case "SHIFT":
modifiers |= EasyModifierKeys.Shift;
break;
case "ALT":
modifiers |= EasyModifierKeys.Alt;
break;
case "WINDOWS":
case "WIN":
modifiers |= EasyModifierKeys.Windows;
break;
default:
throw new NotSupportedException($"Unsupported {token} Modifier");
}
modifiersToken = modifiersToken.Substring(offset + 1);
} while (offset != -1);
}
return(modifiers);
}
internal static string MatchModifiers(EasyModifierKeys modifierKeys)
{
string modifiers = String.Empty;
switch (modifierKeys)
{
case EasyModifierKeys.Control: modifiers = "Ctrl"; break;
case EasyModifierKeys.Shift: modifiers = "Shift"; break;
case EasyModifierKeys.Alt: modifiers = "Alt"; break;
case EasyModifierKeys.Windows: modifiers = "Windows"; break;
}
return(modifiers);
}
private IntPtr HookCallBack(int nCode, IntPtr wParam, IntPtr lParam)
{
int keyState = (int)wParam;
int vkCode = Marshal.ReadInt32(lParam);
var keyPressed = EasyKeyInterop.KeyFromVirtualKey(vkCode);
if (nCode >= 0 && (wParam == (IntPtr)NativeMethods.WM_KEYDOWN || wParam == (IntPtr)NativeMethods.WM_SYSKEYDOWN))
{
if (_pressKeys.IndexOf(keyPressed) < 0)
{
_pressKeys.Add(keyPressed);
}
EasyModifierKeys modifierKeys = default(EasyModifierKeys);
EasyKey easyKey = default(EasyKey);
foreach (var key in _pressKeys)
{
if (TryGetModifierKey(key, out EasyModifierKeys keys))
{
modifierKeys = modifierKeys | keys;
}
else
{
easyKey = easyKey | key;
}
}
var hotKey = new HotKey(easyKey, modifierKeys);
if (_registered.ContainsKey(hotKey))
{
OnKeyPressed(hotKey);
}
}
if (nCode >= 0 && (wParam == (IntPtr)NativeMethods.WM_KEYUP || wParam == (IntPtr)NativeMethods.WM_SYSKEYUP))
{
_pressKeys.Remove(keyPressed);
}
return(EasyWinAPI.CallNextHookEx(_hookId, nCode, wParam, lParam));
}
public HotKey(EasyKey key, EasyModifierKeys modifierKeys)
{
Key = key;
ModifierKeys = modifierKeys;
}
public void Unregister(EasyKey key, EasyModifierKeys modifiers)
{
var hotKey = new HotKey(key, modifiers);
Unregister(hotKey);
}
/// <summary>
/// Check for Valid enum, as any int can be casted to the enum.
/// </summary>
public static bool IsDefinedModifierKeys(EasyModifierKeys modifierKeys)
{
return(modifierKeys == EasyModifierKeys.None || (((int)modifierKeys & ~((int)ModifierKeysFlag)) == 0));
}
