228 lines
8.0 KiB
Python
228 lines
8.0 KiB
Python
import os
|
|
import threading
|
|
|
|
# ── evdev key name → hotkey string mapping ───────────────────────────────────
|
|
_EVDEV_MODIFIER_MAP = {
|
|
"ctrl": {"KEY_LEFTCTRL", "KEY_RIGHTCTRL"},
|
|
"ctrl_l": {"KEY_LEFTCTRL"}, "ctrl_r": {"KEY_RIGHTCTRL"},
|
|
"shift": {"KEY_LEFTSHIFT", "KEY_RIGHTSHIFT"},
|
|
"shift_l": {"KEY_LEFTSHIFT"}, "shift_r": {"KEY_RIGHTSHIFT"},
|
|
"alt": {"KEY_LEFTALT", "KEY_RIGHTALT"},
|
|
"alt_l": {"KEY_LEFTALT"}, "alt_r": {"KEY_RIGHTALT"},
|
|
}
|
|
|
|
_EVDEV_KEY_MAP = {
|
|
"space": "KEY_SPACE", "tab": "KEY_TAB", "enter": "KEY_ENTER",
|
|
"esc": "KEY_ESC", "escape": "KEY_ESC",
|
|
"up": "KEY_UP", "down": "KEY_DOWN", "left": "KEY_LEFT", "right": "KEY_RIGHT",
|
|
"home": "KEY_HOME", "end": "KEY_END", "page_up": "KEY_PAGEUP", "page_down": "KEY_PAGEDOWN",
|
|
"insert": "KEY_INSERT", "delete": "KEY_DELETE", "backspace": "KEY_BACKSPACE",
|
|
}
|
|
for _i in range(1, 13):
|
|
_EVDEV_KEY_MAP[f"f{_i}"] = f"KEY_F{_i}"
|
|
|
|
|
|
def _parse_hotkey_evdev(hotkey_str):
|
|
"""Parse hotkey string into evdev key code sets."""
|
|
parts = [p.strip().lower() for p in hotkey_str.split("+")]
|
|
modifiers = []
|
|
for p in parts[:-1]:
|
|
if p in _EVDEV_MODIFIER_MAP:
|
|
modifiers.append(_EVDEV_MODIFIER_MAP[p])
|
|
elif p in _EVDEV_KEY_MAP:
|
|
modifiers.append({_EVDEV_KEY_MAP[p]})
|
|
else:
|
|
modifiers.append({f"KEY_{p.upper()}"})
|
|
trigger_part = parts[-1]
|
|
if trigger_part in _EVDEV_KEY_MAP:
|
|
trigger = _EVDEV_KEY_MAP[trigger_part]
|
|
elif trigger_part in _EVDEV_MODIFIER_MAP:
|
|
trigger = next(iter(_EVDEV_MODIFIER_MAP[trigger_part]))
|
|
else:
|
|
trigger = f"KEY_{trigger_part.upper()}"
|
|
return modifiers, trigger
|
|
|
|
|
|
def _can_use_evdev():
|
|
"""Check if evdev is available and we have access to input devices."""
|
|
if os.name == "nt":
|
|
return False
|
|
try:
|
|
import evdev
|
|
devices = [evdev.InputDevice(p) for p in evdev.list_devices()]
|
|
keyboards = [d for d in devices if 1 in d.capabilities()] # EV_KEY
|
|
for d in devices:
|
|
d.close()
|
|
return len(keyboards) > 0
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
class _EvdevListener:
|
|
"""Low-latency hotkey listener using evdev (Linux kernel input)."""
|
|
|
|
def __init__(self, hotkey_str, on_press, on_release):
|
|
self._modifiers, self._trigger = _parse_hotkey_evdev(hotkey_str)
|
|
self._on_press = on_press
|
|
self._on_release = on_release
|
|
self._pressed = set()
|
|
self._active = False
|
|
self._stop_event = threading.Event()
|
|
self._thread = threading.Thread(target=self._run, daemon=True)
|
|
self._thread.start()
|
|
|
|
def _run(self):
|
|
import evdev
|
|
import select
|
|
|
|
devices = [evdev.InputDevice(p) for p in evdev.list_devices()]
|
|
keyboards = [d for d in devices if 1 in d.capabilities()]
|
|
# close non-keyboard devices
|
|
for d in devices:
|
|
if d not in keyboards:
|
|
d.close()
|
|
|
|
if not keyboards:
|
|
return
|
|
|
|
while not self._stop_event.is_set():
|
|
r, _, _ = select.select(keyboards, [], [], 0.5)
|
|
for dev in r:
|
|
try:
|
|
for event in dev.read():
|
|
if event.type != 1: # EV_KEY
|
|
continue
|
|
code_name = evdev.ecodes.KEY.get(event.code)
|
|
if isinstance(code_name, list):
|
|
code_name = code_name[0]
|
|
if code_name is None:
|
|
continue
|
|
if event.value == 1: # key down
|
|
self._key_down(code_name)
|
|
elif event.value == 0: # key up
|
|
self._key_up(code_name)
|
|
except OSError:
|
|
pass
|
|
|
|
for d in keyboards:
|
|
d.close()
|
|
|
|
def _key_down(self, code_name):
|
|
self._pressed.add(code_name)
|
|
if not self._active and code_name == self._trigger and self._modifiers_held():
|
|
self._active = True
|
|
self._on_press()
|
|
|
|
def _key_up(self, code_name):
|
|
self._pressed.discard(code_name)
|
|
if self._active and code_name == self._trigger:
|
|
self._active = False
|
|
self._on_release()
|
|
|
|
def _modifiers_held(self):
|
|
return all(
|
|
any(k in self._pressed for k in mod_set)
|
|
for mod_set in self._modifiers
|
|
)
|
|
|
|
def stop(self):
|
|
self._stop_event.set()
|
|
|
|
|
|
# ── pynput fallback (Windows, or Linux without evdev/input group) ────────────
|
|
|
|
_pynput_loaded = False
|
|
Key = KeyCode = KeyboardListener = None
|
|
_PYNPUT_MODIFIER_MAP = {}
|
|
_PYNPUT_KEY_MAP = {}
|
|
|
|
|
|
def _ensure_pynput():
|
|
global _pynput_loaded, Key, KeyCode, KeyboardListener
|
|
if _pynput_loaded:
|
|
return
|
|
from pynput.keyboard import Listener as _Listener, Key as _Key, KeyCode as _KeyCode
|
|
Key = _Key
|
|
KeyCode = _KeyCode
|
|
KeyboardListener = _Listener
|
|
_PYNPUT_MODIFIER_MAP.update({
|
|
"ctrl": {Key.ctrl_l, Key.ctrl_r},
|
|
"ctrl_l": {Key.ctrl_l}, "ctrl_r": {Key.ctrl_r},
|
|
"shift": {Key.shift_l, Key.shift_r},
|
|
"shift_l": {Key.shift_l}, "shift_r": {Key.shift_r},
|
|
"alt": {Key.alt_l, Key.alt_r},
|
|
"alt_l": {Key.alt_l}, "alt_r": {Key.alt_r},
|
|
})
|
|
_PYNPUT_KEY_MAP.update({
|
|
"space": Key.space, "tab": Key.tab, "enter": Key.enter,
|
|
"esc": Key.esc, "escape": Key.esc,
|
|
"up": Key.up, "down": Key.down, "left": Key.left, "right": Key.right,
|
|
"home": Key.home, "end": Key.end, "page_up": Key.page_up, "page_down": Key.page_down,
|
|
"insert": Key.insert, "delete": Key.delete, "backspace": Key.backspace,
|
|
})
|
|
for i in range(1, 13):
|
|
_PYNPUT_KEY_MAP[f"f{i}"] = getattr(Key, f"f{i}")
|
|
_pynput_loaded = True
|
|
|
|
|
|
def _parse_hotkey_pynput(hotkey_str):
|
|
_ensure_pynput()
|
|
parts = [p.strip().lower() for p in hotkey_str.split("+")]
|
|
modifiers = []
|
|
for p in parts[:-1]:
|
|
if p in _PYNPUT_MODIFIER_MAP:
|
|
modifiers.append(_PYNPUT_MODIFIER_MAP[p])
|
|
elif p in _PYNPUT_KEY_MAP:
|
|
modifiers.append({_PYNPUT_KEY_MAP[p]})
|
|
else:
|
|
modifiers.append({KeyCode.from_char(p)})
|
|
trigger_part = parts[-1]
|
|
if trigger_part in _PYNPUT_KEY_MAP:
|
|
trigger = _PYNPUT_KEY_MAP[trigger_part]
|
|
elif trigger_part in _PYNPUT_MODIFIER_MAP:
|
|
trigger = next(iter(_PYNPUT_MODIFIER_MAP[trigger_part]))
|
|
else:
|
|
trigger = KeyCode.from_char(trigger_part)
|
|
return modifiers, trigger
|
|
|
|
|
|
class _PynputListener:
|
|
"""Hotkey listener using pynput (Windows / fallback)."""
|
|
|
|
def __init__(self, hotkey_str, on_press, on_release):
|
|
self._modifiers, self._trigger = _parse_hotkey_pynput(hotkey_str)
|
|
self._on_press = on_press
|
|
self._on_release = on_release
|
|
self._pressed = set()
|
|
self._active = False
|
|
self._listener = KeyboardListener(on_press=self._key_down, on_release=self._key_up)
|
|
self._listener.daemon = True
|
|
self._listener.start()
|
|
|
|
def _key_down(self, key):
|
|
self._pressed.add(key)
|
|
if not self._active and key == self._trigger and self._modifiers_held():
|
|
self._active = True
|
|
self._on_press()
|
|
|
|
def _key_up(self, key):
|
|
self._pressed.discard(key)
|
|
if self._active and key == self._trigger:
|
|
self._active = False
|
|
self._on_release()
|
|
|
|
def _modifiers_held(self):
|
|
return all(any(k in self._pressed for k in mod_set) for mod_set in self._modifiers)
|
|
|
|
def stop(self):
|
|
self._listener.stop()
|
|
|
|
|
|
# ── Public API ───────────────────────────────────────────────────────────────
|
|
|
|
def HotkeyListener(hotkey_str, on_press, on_release):
|
|
"""Create the best available hotkey listener for the current platform."""
|
|
if _can_use_evdev():
|
|
return _EvdevListener(hotkey_str, on_press, on_release)
|
|
return _PynputListener(hotkey_str, on_press, on_release)
|