/// <summary>
/// 注册一个全局热键。
/// </summary>
/// <param name="keys">键。</param>
public int RegisterHotkey(Keys keys)
{
int hotkeyid = GlobalAddAtom(Guid.NewGuid().ToString());
this._keyList.Add(keys, hotkeyid);
HotkeyModifiers modifiers = HotkeyModifiers.None;
if ((keys & Keys.Control) == Keys.Control)
{
modifiers |= HotkeyModifiers.Control;
keys = keys & ~Keys.Control;
}
if ((keys & Keys.Alt) == Keys.Alt)
{
modifiers |= HotkeyModifiers.Alt;
keys = keys & ~Keys.Alt;
}
if ((keys & Keys.Shift) == Keys.Shift)
{
modifiers |= HotkeyModifiers.Shift;
keys = keys & ~Keys.Shift;
}
if ((keys & Keys.LWin) == Keys.LWin)
{
modifiers |= HotkeyModifiers.Windows;
keys = keys & ~Keys.LWin;
}
RegisterHotKey(_hWnd, hotkeyid, (int)modifiers, (int)keys);
return(hotkeyid);
}
public Hotkey(uint virtualKey, HotkeyModifiers flags, EventHandler <HotkeyEventArgs> handler)
{
this.Id = ++nextId;
this.VirtualKey = virtualKey;
this.Modifiers = flags;
this.Handler = handler;
}
public void SetClientHotkey(ISClientInfoModel client, ISHotkeyModel cHk)
{
HotkeyModifiers mods = 0;
mods = cHk.Alt ? mods |= HotkeyModifiers.Alt : mods;
mods = cHk.Ctrl ? mods |= HotkeyModifiers.Ctrl : mods;
mods = cHk.Shift ? mods |= HotkeyModifiers.Shift : mods;
//Translate from avalonia to windows virtual key
try
{
#if WindowsBuild
System.Windows.Input.Key a = (System.Windows.Input.Key)cHk.Key;
Hotkey k = new Hotkey((WindowsVirtualKey)KeyInterop.VirtualKeyFromKey(a), mods);
#else
//Translate from avalonia key to windows virtual key
//This is a dirty method but should work for the majority of keys
var a = (WindowsVirtualKey)Enum.Parse(typeof(WindowsVirtualKey), cHk.Key.ToString());
Hotkey k = new Hotkey(a, mods);
#endif
client.SetHotkey(k);
}catch (Exception ex)
{
ISLogger.Write("Failed to set hotkey: " + ex.Message);
}
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="hWnd">持有快捷键窗口的句柄</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="vk">快捷键的虚拟键码</param>
/// <param name="callBack">回调函数</param>
public static void Regist(IntPtr hWnd, HotkeyModifiers fsModifiers, Keys vk, HotKeyCallBackHanlder callBack)
{
int id = keyid++;
if (!RegisterHotKey(hWnd, id, fsModifiers, vk))
throw new Exception("regist hotkey fail.");
keymap[id] = callBack;
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="hWnd">句柄，</param>
/// <param name="modifiers"></param>
/// <param name="vk"></param>
/// <param name="callBack"></param>
public static void Regist(IntPtr ptr, HotkeyModifiers modifiers, Keys vk, HotKeyCallBackHanlder callBack)
{
if (!Win32Api.RegisterHotKey(ptr, keyid, (int)modifiers, vk))
{
throw new Exception("注册失败！");
}
keymap[keyid++] = callBack;
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="hWnd">持有快捷键窗口的句柄</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="vk">快捷键的虚拟键码</param>
/// <param name="callBack">回调函数</param>
public static void Regist(IntPtr hWnd, HotkeyModifiers fsModifiers, Keys vk, HotKeyCallBackHanlder callBack)
{
int id = keyid++;
if (!RegisterHotKey(hWnd, id, fsModifiers, vk))
{
return;
}
keymap[id] = callBack;
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="hWnd">持有快捷键窗口的句柄</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="vk">快捷键的虚拟键码</param>
/// <param name="callBack">回调函数</param>
public static void Regist(IntPtr hWnd, HotkeyModifiers fsModifiers, Keys vk, HotKeyCallBackHanlder callBack)
{
int id = keyid++;
if (!RegisterHotKey(hWnd, id, fsModifiers, vk))
{
throw new Exception("regist hotkey fail.");
}
keymap[id] = callBack;
}
public void RegisterKeyAction(Keys key, HotkeyModifiers modifier, Action action)
{
var hotkeyCombination = new HotkeyCombination
{
Key = key,
Modifier = modifier
};
hotkeyActions[hotkeyCombination] = action;
}
private void SetDefaultHotkeys()
{
try
{
HotkeyModifiers mods = HotkeyModifiers.Alt | HotkeyModifiers.Ctrl | HotkeyModifiers.Shift;
inputMan.AddUpdateFunctionHotkey(new Input.Hotkeys.FunctionHotkey(WindowsVirtualKey.Q, mods, Input.Hotkeys.Hotkeyfunction.StopServer));
inputMan.AddUpdateFunctionHotkey(new FunctionHotkey(WindowsVirtualKey.P, HotkeyModifiers.Alt | HotkeyModifiers.Ctrl, Hotkeyfunction.SendSas));
}
catch (Exception ex)
{
ISLogger.Write("Failed to set default hotkeys: " + ex.Message);
}
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="window">持有快捷键窗口</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="key">快捷键</param>
/// <param name="callBack">回调函数</param>
public static void Regist(IntPtr hwnd, HotkeyModifiers fsModifiers, Key key, HotKeyCallBackHanlder callBack)
{
var _hwndSource = HwndSource.FromHwnd(hwnd);
_hwndSource.AddHook(WndProc);
int id = keyid++;
var vk = KeyInterop.VirtualKeyFromKey(key);
if (!RegisterHotKey(hwnd, id, fsModifiers, (uint)vk))
{
throw new Exception("regist hotkey fail.");
}
keymap[id] = callBack;
}
// Token: 0x06000490 RID: 1168 RVA: 0x0000EB88 File Offset: 0x0000CD88
private void SetModifierKey(HotkeyModifiers modifierKey, bool value)
{
HotkeyModifiers hotkeyModifiers = this.modifierKeys;
if (value)
{
this.modifierKeys |= modifierKey;
}
else
{
this.modifierKeys &= ~modifierKey;
}
if (this.modifierKeys != hotkeyModifiers)
{
this.Update();
}
}
public string RegisterHotKey(int id, uint mods, uint keys)
{
HotkeyModifiers modifiers = (HotkeyModifiers)mods;
Keys? key = (Keys)keys;
if (!RegisterHotKey(Handle, id, modifiers, key.Value))
{
var exception = new Win32Exception();
if ((uint)exception.HResult == 0x80004005)
{
// Hot key is already registered, so we can ignore.
return(null);
}
return("bind error: " + exception);
}
return(null);
}
protected void AddOrReplace(string name,
uint virtualKey,
HotkeyModifiers flags,
EventHandler <HotkeyEventArgs> handler)
{
var hotkey = new Hotkey(virtualKey, flags, handler);
lock (this.hotkeys)
{
this.Remove(name);
this.hotkeys.Add(name, hotkey);
this.hotkeyNames.Add(hotkey.Id, name);
if (this.WindowHandle != IntPtr.Zero)
{
hotkey.Register(this.WindowHandle, name);
}
}
}
private static void Cmd_Assign(string arg1)
{
ClientInfo clientA = GetClientFromName(arg1);
if (clientA == null)
{
Console.WriteLine("Invalid client.");
ListClients();
return;
}
Console.WriteLine("Hotkey to assign to " + clientA.Name);
ConsoleKeyInfo keyInfo = Console.ReadKey(true);
HotkeyModifiers mods = 0;
if (keyInfo.Modifiers.HasFlag(ConsoleModifiers.Control))
{
mods |= HotkeyModifiers.Ctrl;
}
if (keyInfo.Modifiers.HasFlag(ConsoleModifiers.Alt))
{
mods |= HotkeyModifiers.Alt;
}
if (keyInfo.Modifiers.HasFlag(ConsoleModifiers.Shift))
{
mods |= HotkeyModifiers.Shift;
}
try
{
server.SetHotkeyForClient(clientA, new Hotkey((WindowsVirtualKey)keyInfo.Key, mods));
}
catch (Exception ex)
{
Console.WriteLine("Failed to set hotkey: " + ex.Message);
}
}
private LinuxKeyMask ConvertMask(HotkeyModifiers mods)
{
LinuxKeyMask mask = 0;
if (mods.HasFlag(HotkeyModifiers.Alt))
{
mask |= LinuxKeyMask.AltMask;
}
if (mods.HasFlag(HotkeyModifiers.Ctrl))
{
mask |= LinuxKeyMask.ControlMask;
}
if (mods.HasFlag(HotkeyModifiers.Shift))
{
mask |= LinuxKeyMask.ShiftMask;
}
if (mods.HasFlag(HotkeyModifiers.Windows))
{
mask |= LinuxKeyMask.WindowsMask;
}
return(mask);
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="window">持有快捷键窗口</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="key">快捷键</param>
/// <param name="callBack">回调函数</param>
public static bool Regist(Window window, HotkeyModifiers fsModifiers, Key key, HotKeyCallBackHanlder callBack)
{
var hwnd = new WindowInteropHelper(window).Handle;
var _hwndSource = HwndSource.FromHwnd(hwnd);
if (keyid == 10)
{
_hwndSource.AddHook(WndProc);
}
int id = keyid++;
var vk = KeyInterop.VirtualKeyFromKey(key);
if (!RegisterHotKey(hwnd, id, fsModifiers, (uint)vk))
{
//throw new Exception("regist hotkey fail.");
return(false);
}
keymap[id] = callBack;
return(true);
}
private static Hotkey FromSettingsString(string hkStr)
{
string[] args = hkStr.Split(':');
if (args.Length == 0)
{
return(null);
}
if (!WindowsVirtualKey.TryParse(typeof(WindowsVirtualKey), args[0], true, out var keyObj))
{
return(null);
}
WindowsVirtualKey key = (WindowsVirtualKey)keyObj;
HotkeyModifiers mods = 0;
for (int i = 1; i < args.Length; i++)
{
string modStr = args[i];
if (modStr == HotkeyModifiers.Alt.ToString())
{
mods |= HotkeyModifiers.Alt;
}
else if (modStr == HotkeyModifiers.Ctrl.ToString())
{
mods |= HotkeyModifiers.Ctrl;
}
else if (modStr == HotkeyModifiers.Shift.ToString())
{
mods |= HotkeyModifiers.Shift;
}
}
return(new Hotkey(key, mods));
}
// Token: 0x06000489 RID: 1161 RVA: 0x0000E9DF File Offset: 0x0000CBDF
public Hotkey(Control registerControl, Keys keyCode, HotkeyModifiers modifierKeys) : this(keyCode, modifierKeys)
{
this.Register(registerControl);
}
static extern bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers fsModifiers, uint vk);
// Token: 0x06000488 RID: 1160 RVA: 0x0000E9C3 File Offset: 0x0000CBC3
public Hotkey(Keys keyCode, HotkeyModifiers modifierKeys)
{
this.keyCode = keyCode;
this.modifierKeys = modifierKeys;
Application.AddMessageFilter(this);
}
/// <summary>
/// 注册快捷键
/// </summary>
/// <param name="hWnd">持有快捷键窗口的句柄</param>
/// <param name="fsModifiers">组合键</param>
/// <param name="vk">快捷键的虚拟键码</param>
/// <param name="callBack">回调函数</param>
public static void Regist(IntPtr hWnd, HotkeyModifiers fsModifiers, Keys vk, HotKeyCallBackHanlder callBack)
{
int id = keyid++;
if (!RegisterHotKey(hWnd, id, fsModifiers, vk)) return;
keymap[id] = callBack;
}
internal void Clear()
{
_Modifiers = HotkeyModifiers.MOD_NONE;
_Shortcut = "";
_vk = 0;
}
public Hotkey(WindowsVirtualKey key, HotkeyModifiers mods)
{
Key = key;
Modifiers = mods;
}
public ClientHotkey(WindowsVirtualKey key, HotkeyModifiers mods, Guid targetClient) : base(key, mods)
{
TargetClient = targetClient;
}
public static bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers modifiers, uint virtualKey)
{
return(RegisterHotkey(hWnd, id, (uint)modifiers, virtualKey));
}
static extern bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers fsModifiers, Keys vk);
private static extern bool RegisterHotKey(IntPtr hwnd, int id, HotkeyModifiers modifiers, Keys vk);
public static extern bool RegisterHotKey(IntPtr hWnd, int id, HotkeyModifiers modifers, Keys vk);
internal void CopyFrom(PNHotKey hk)
{
_Modifiers = hk.Modifiers;
_Shortcut = hk._Shortcut;
_vk = hk._vk;
}
public FunctionHotkey(WindowsVirtualKey key, HotkeyModifiers mods, Hotkeyfunction function) : base(key, mods)
{
Function = function;
}
/// <summary>
/// Regist a hotkey, it will return: status code + hot key in string + hot key id
/// </summary>
public Tuple <RetCode, string, int> Regist(Window window, HotkeyModifiers hotkeyModifiers, System.Windows.Input.Key key, HotKeyCallBackHandler callBack)
{
return(Regist(window, (uint)hotkeyModifiers, key, callBack));
}
