One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Windows capture to Linux input planning, without a GUI or native input injection."""
from pathlib import Path
from types import SimpleNamespace
import sys
import unittest
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "win_app"))
import capture_win
import inject_portal
import inject_x11
import sender
from core import owner, protocol
class AccentKeymap:
# Spanish-like dead accents, plus an AltGr vowel. AltGr is deliberately Mod3.
KEYS = {26: ("e", "E"), 32: ("o", "O"), 30: ("u", "U"), 31: ("i", "I"),
48: (0xfe51, 0xfe52), 49: (0xfe57, 0xfe57), 50: (0xffe1, 0xffe1),
108: (0xfe03, 0xfe03)}
min_keycode, max_keycode = 8, 255
def keysym(self, code, mods, group):
if group != 0:
return 0
if code == 31 and mods & 32:
return 0x20ac # EuroSign is a legacy XKB keysym, not a Unicode-prefixed one.
if code == 26 and mods & 32:
return ord("É" if mods & 1 else "é")
pair = self.KEYS.get(code)
if pair is None:
return 0
upper = bool(mods & 1) != bool(mods & 2 and isinstance(pair[0], str))
value = pair[int(upper)]
return ord(value) if isinstance(value, str) else value
def modifier_mask(self, code):
return {50: 1, 108: 32}.get(code, 0)
def text(self, sym):
return chr(sym) if 0 < sym < 0xfe00 else None
def empty(self, code):
return code not in self.KEYS
class CaptureApi:
def GetForegroundWindow(self):
return 99
def GetWindowThreadProcessId(self, window, process):
return 17
def GetKeyboardLayout(self, thread):
return "Spanish" if thread == 17 else "US"
def ToUnicodeEx(self, vk, scan, state, buffer, size, flags, layout):
if vk == 0xde:
buffer[0] = "´" if layout == "Spanish" else "'"
return -1 if layout == "Spanish" else 1
buffer[0] = "e"
return 1
class AccentTests(unittest.TestCase):
def test_capture_reads_foreground_layout_instead_of_hook_thread_layout(self):
state = capture_win.KeyboardState()
with patch.object(capture_win, "user32", CaptureApi()):
dead = capture_win.key_name(0xde, 0, state, capture_win._to_unicode)
self.assertIsInstance(dead, capture_win.DeadKey)
self.assertEqual(capture_win.key_name(0x45, 0, state, capture_win._to_unicode), "é")
def test_no_foreground_window_uses_hook_layout(self):
api = CaptureApi()
api.GetForegroundWindow = lambda: 0
with patch.object(capture_win, "user32", api):
self.assertEqual(capture_win._to_unicode(0xde, 0, {}), "'")
def test_altgr_printable_uses_text_but_unchanged_shortcut_stays_a_key(self):
state = capture_win.KeyboardState()
state.altgr_down = True
def translate(vk, scan, modifiers):
return "é" if modifiers.get(0x12, 0) & 0x80 else "e"
translated = capture_win.key_name(0x45, 0, state, translate)
self.assertIsInstance(translated, capture_win.TextInput)
self.assertEqual(translated.text, "é")
self.assertEqual(capture_win.key_name(0x45, 0, state, lambda *args: "e"), "e")
def test_windows_dead_keys_survive_sender_wire_and_both_linux_planners(self):
for accent, base, want, strokes in (("´", "e", "é", [26]),
("^", "o", "ô", [48, 32]),
("¨", "u", "ü", [49, 30])):
for layout_class in (inject_x11.Layout, inject_portal.WaylandLayout):
with self.subTest(accent=accent, backend=layout_class.__name__):
keyboard = capture_win.KeyboardState()
translate = lambda vk, scan, mods: capture_win.DeadKey(accent) if vk == 0xde else base
link_sender = self.link_sender()
dead = capture_win.key_name(0xde, 0, keyboard, translate)
self.assertTrue(link_sender.on_dead_key(0xde))
self.assertIsInstance(dead, capture_win.DeadKey)
capture_win.key_name(0xde, 0, keyboard, translate, False)
name = capture_win.key_name(ord(base.upper()), 0, keyboard, translate)
self.assertEqual(name, want)
self.assertTrue(link_sender.on_key(name, True, ord(base.upper()), base))
self.assertTrue(link_sender.on_key(base, False, ord(base.upper()), base))
messages = self.messages(link_sender)
self.assertEqual([m["key"] for m in messages], [want, want])
state = inject_x11.KeyState()
layout = layout_class(AccentKeymap())
steps = []
for read in messages:
steps += inject_x11.plan_key(read["key"], read["type"] == "keydown", read["us"], state, layout, 0, 0)
presses = [s[1] for s in steps if s[0] == inject_x11.PRESS and s[1] not in (50, 108)]
if layout.can_remap:
self.assertEqual(steps, [(inject_x11.MAP, 255, ord(want), False),
(inject_x11.PRESS, 255), (inject_x11.RELEASE, 255)])
else:
self.assertFalse(any(step[0] == inject_x11.MAP for step in steps))
self.assertEqual(presses, strokes)
self.assertEqual(state.chars_down, {})
def test_text_and_repeated_composed_keys_restore_modifiers_and_release_strokes(self):
for locks in (0, 2):
with self.subTest(locks=locks):
state = inject_x11.KeyState()
state.mods_down = {"shift_r"}
layout = inject_portal.WaylandLayout(AccentKeymap())
steps = inject_x11.plan_key("ô", True, "o", state, layout, 0, locks)
self.assertTrue(steps)
self.assertEqual(steps, inject_x11.plan_key("ô", True, "o", state, layout, 0, locks))
self.assertEqual(inject_x11.plan_key("ô", False, "o", state, layout, 0, locks), [])
self.assertEqual(steps[0], (inject_x11.RELEASE, 62))
self.assertEqual(steps[-1], (inject_x11.PRESS, 62))
self.assertEqual(state.mods_down, {"shift_r"})
self.assertEqual(state.chars_down, {})
self.assertTrue(inject_x11.plan_text("éôü", state, layout, 0, locks))
def test_altgr_text_from_sender_brackets_ctrl_alt_and_reaches_wayland(self):
link_sender = self.link_sender()
link_sender.on_key("cmd", True, 0xa2)
link_sender.on_key("alt_r", True, 0xa5)
link_sender.on_text("é", 0x45)
messages = self.messages(link_sender)
self.assertTrue(any(m.get("text") == "é" for m in messages))
state = inject_x11.KeyState()
layout = inject_portal.WaylandLayout(AccentKeymap())
for read in messages:
if read["type"] == "text":
steps = inject_x11.plan_text(read["text"], state, layout, 0, 0)
self.assertIn((inject_x11.PRESS, 26), steps)
self.assertEqual(state.mods_down, set())
else:
inject_x11.plan_key(read["key"], read["type"] == "keydown", read["us"], state, layout, 0, 0)
self.assertEqual(state.mods_down, {"ctrl", "alt_r"})
def test_unavailable_layout_character_and_chord_are_not_replaced_with_compose(self):
state = inject_x11.KeyState()
layout = inject_portal.WaylandLayout(AccentKeymap())
self.assertEqual(inject_x11.plan_key("ô", True, None, state, layout, 1, 0), [])
state.mods_down = {"ctrl"}
self.assertEqual(inject_x11.plan_key("ô", True, "o", state, layout, 0, 0), [(inject_x11.PRESS, 32)])
def test_legacy_altgr_keysym_is_looked_up_by_its_unicode_text(self):
layout = inject_portal.WaylandLayout(AccentKeymap())
steps = inject_x11.plan_text("€", inject_x11.KeyState(), layout, 0, 0)
self.assertIn((inject_x11.PRESS, 31), steps)
def test_repeated_composition_follows_lock_changes(self):
layout = inject_portal.WaylandLayout(AccentKeymap())
state = inject_x11.KeyState()
first = inject_x11.plan_key("ô", True, "o", state, layout, 0, 0)
repeat = inject_x11.plan_key("ô", True, "o", state, layout, 0, 2)
self.assertNotEqual(repeat, first)
self.assertIn((inject_x11.PRESS, 50), repeat[-5:])
self.assertEqual(inject_x11.plan_key("ô", False, "o", state, layout, 0, 2), [])
def test_composition_does_not_release_another_held_character(self):
layout = inject_portal.WaylandLayout(AccentKeymap())
state = inject_x11.KeyState()
inject_x11.plan_key("o", True, "o", state, layout, 0, 0)
self.assertEqual(inject_x11.plan_key("ô", True, None, state, layout, 0, 0), [])
self.assertEqual(state.chars_down, {"o": (32, None)})
def test_altgr_dead_key_keeps_composition_until_the_next_character(self):
state = capture_win.KeyboardState()
state.altgr_down = True
def translate(vk, scan, modifiers):
return capture_win.DeadKey("´") if vk == 0xde and modifiers.get(0x12) else "e"
self.assertIsInstance(capture_win.key_name(0xde, 0, state, translate), capture_win.DeadKey)
result = capture_win.key_name(0x45, 0, state, translate)
self.assertIsInstance(result, capture_win.TextInput)
self.assertEqual(result.text, "é")
@staticmethod
def link_sender():
result = sender.LinkSender(None, lambda: {}, links=lambda _: SimpleNamespace(live=lambda peer: True))
result._owner = owner.Owner(bytes(range(16)), lambda: 0)
result._owner.on = bytes(range(16, 32))
return result
@staticmethod
def messages(link_sender):
messages = []
while not link_sender._outbound.empty():
action = link_sender._outbound.get_nowait()
message = dict(action.message)
message["data"] = dict(message["data"], seq=len(messages) + 1)
messages.append(protocol.read_input(protocol.parse_message(protocol.dumps_message(message))))
return messages
if __name__ == "__main__":
unittest.main()