Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

Beamer 1.5.19

Toby Kalkmana2ee40ee0967
diff --git a/VERSION b/VERSION
index 83d4cf8..e7a15ce 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.5.18
+1.5.19
diff --git a/core/capture_types.py b/core/capture_types.py
index 7e7f112..d709107 100644
--- a/core/capture_types.py
+++ b/core/capture_types.py
@@ -4,8 +4,9 @@ import unicodedata
class DeadKey:
- def __init__(self, character: str) -> None:
+ def __init__(self, character: str, compositions=None) -> None:
self.character = character
+ self.compositions = compositions
class TextInput:
@@ -53,14 +54,18 @@ class MacDeadKeys:
self.pending = None
return None
if isinstance(translation, DeadKey):
- accent = translation.character
- text = self.pending or ""
- self.pending = None if self.pending == accent else accent
+ text = self.pending.character if self.pending else ""
+ self.pending = None if (self.pending and self.pending.character == translation.character) else translation
self.swallowed[code] = ""
return text
if self.pending and isinstance(translation, str) and translation.isprintable():
- accent, self.pending = self.pending, None
- result = accent if translation == " " else compose_dead_key(accent, translation)
+ dead, self.pending = self.pending, None
+ if translation == " ":
+ result = dead.character
+ elif dead.compositions is not None:
+ result = dead.compositions.get(translation, dead.character + translation)
+ else:
+ result = compose_dead_key(dead.character, translation)
self.swallowed[code] = translation
return result.text if isinstance(result, TextInput) else result
self.pending = None
diff --git a/core/tests/test_flatpak_libei_path.py b/core/tests/test_flatpak_libei_path.py
new file mode 100644
index 0000000..63b4618
--- /dev/null
+++ b/core/tests/test_flatpak_libei_path.py
@@ -0,0 +1,17 @@
+import json
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class FlatpakLibeiPathTests(unittest.TestCase):
+ def test_libei_installs_in_flatpak_runtime_library_path(self):
+ manifest = json.loads((ROOT / "uk.co.kalkman.beamer.json").read_text(encoding="utf-8"))
+ libei = next(module for module in manifest["modules"] if module["name"] == "libei")
+ self.assertIn("--libdir=lib", libei["config-opts"],
+ "Flatpak loads /app/lib; Meson's host default can select /app/lib64")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_ghlinux_arrival.py b/core/tests/test_ghlinux_arrival.py
new file mode 100644
index 0000000..b554460
--- /dev/null
+++ b/core/tests/test_ghlinux_arrival.py
@@ -0,0 +1,80 @@
+"""Linux regressions against production methods, without loading Qt or native input modules."""
+
+import ast
+from pathlib import Path
+import threading
+from types import SimpleNamespace as NS
+import unittest
+from typing import Optional
+from unittest.mock import Mock
+
+from core import return_edge
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def functions(filename, names, namespace, owner=None):
+ path = ROOT / "win_app" / filename
+ body = ast.parse(path.read_text(encoding="utf-8")).body
+ if owner:
+ body = next(node.body for node in body if isinstance(node, ast.ClassDef) and node.name == owner)
+ selected = [node for node in body if isinstance(node, ast.FunctionDef) and node.name in names]
+ exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), namespace)
+ return namespace
+
+
+class WaylandArrival(unittest.TestCase):
+ def setUp(self):
+ self.methods = functions("sender.py", {"zone_models", "_press_edge"},
+ {"return_edge": return_edge, "LOGGER": Mock()}, "LinkSender")
+ self.model = return_edge.PartEdge("left", ["middle"], 10)
+ self.sender = NS(_lock=threading.RLock(), _owner=object(), driven=lambda: True,
+ _refresh_display_peers=Mock(), _display_peer_models=[],
+ _represented_displays=lambda: set(), edges_held=False,
+ _models=[(b"peer", self.model)], receiving_split=lambda: False,
+ _home_hold=None, push_out=Mock(), _buttons_held=set(),
+ _desktop_module=Mock(side_effect=AssertionError("local crossing was evaluated")))
+
+ def test_arrival_removes_overlapping_local_barriers_until_the_visit_ends(self):
+ self.assertEqual(self.methods["zone_models"](self.sender), [])
+ self.sender.driven = lambda: False
+ self.assertEqual(self.methods["zone_models"](self.sender), [self.model])
+
+ def test_a_stale_captured_move_cannot_start_the_links_home_thread(self):
+ self.methods["_press_edge"](self.sender, -120, 0)
+ self.sender._desktop_module.assert_not_called()
+
+ def test_receiver_return_still_holds_arrival_then_crosses_deliberately(self):
+ now = [1.0]
+ model = return_edge.PartEdge("left", ["middle"], 10, clock=lambda: now[0])
+ model.start_grace()
+ screen = [return_edge.Rect(0, 0, 100, 100)]
+ now[0] += 0.003
+ self.assertEqual(model.feed(screen, (0, 50), -120, 0).action, return_edge.HOLD)
+ now[0] += return_edge.ARRIVAL_GRACE_SECONDS
+ self.assertEqual(model.feed(screen, (0, 50), -120, 0).action, return_edge.CROSS)
+
+ def test_native_local_mouse_can_still_take_over_while_driven(self):
+ s = self.sender
+ s.push_out = None
+ screen = return_edge.Rect(0, 0, 100, 100)
+ s._desktop_module = lambda: NS(cursor_position=lambda: (0, 50))
+ s._cached_monitors = lambda: [screen]
+ s._cached_display_map = lambda: {}
+ s._go, s._notify_pressure = Mock(), Mock()
+ self.methods["_press_edge"](s, -120, 0)
+ s._go.assert_called_once_with(b"peer", "right", 0.5, None, None)
+
+ def test_wayland_local_crossing_returns_after_the_peer_lets_go(self):
+ self.sender.driven = lambda: False
+ screen = return_edge.Rect(0, 0, 100, 100)
+ self.sender._desktop_module = lambda: NS(cursor_position=lambda: (0, 50))
+ self.sender._cached_monitors = lambda: [screen]
+ self.sender._cached_display_map = lambda: {}
+ self.sender._go, self.sender._notify_pressure = Mock(), Mock()
+ self.methods["_press_edge"](self.sender, -120, 0)
+ self.sender._go.assert_called_once_with(b"peer", "right", 0.5, None, None)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_ghlinux_clipboard.py b/core/tests/test_ghlinux_clipboard.py
new file mode 100644
index 0000000..b596fab
--- /dev/null
+++ b/core/tests/test_ghlinux_clipboard.py
@@ -0,0 +1,92 @@
+"""X11 stamp notifications against production methods with a fake GUI dispatcher."""
+
+from types import SimpleNamespace as NS
+from typing import Optional
+import unittest
+from unittest.mock import Mock
+
+import ast
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def functions(filename, names, namespace, owner=None):
+ path = ROOT / "win_app" / filename
+ body = ast.parse(path.read_text(encoding="utf-8")).body
+ if owner:
+ body = next(node.body for node in body if isinstance(node, ast.ClassDef) and node.name == owner)
+ selected = [node for node in body if isinstance(node, ast.FunctionDef) and node.name in names]
+ exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), namespace)
+ return namespace
+
+
+class X11Stamps(unittest.TestCase):
+ def setUp(self):
+ self.handlers = []
+ self.own = False
+ signal = NS(connect=self.handlers.append)
+ self.clipboard = NS(dataChanged=signal)
+ self.app = object()
+ gui = NS(instance=lambda: self.app, clipboard=lambda: self.clipboard)
+ self.ns = functions("clipboard_x11.py", {"change_stamp", "write_stamp", "_on_data_changed", "_connect",
+ "_stamp", "_write"},
+ {"QGuiApplication": gui, "_connected_to": None, "_change_counter": 0,
+ "_synced_counter": None, "_write_stamp": None,
+ "Optional": Optional, "QMimeData": Mock, "_own_token": 0,
+ "OWN_FORMAT": "application/x-beamer-own", "PNG_MIME": "image/png",
+ "_is_own_write": lambda clipboard: self.own,
+ "_on_gui": lambda fn, *args, default: fn(*args) if self.app else default})
+
+ def notify(self):
+ for handler in self.handlers:
+ handler()
+
+ def test_first_stamp_observation_connects_local_copy_notifications(self):
+ before = self.ns["change_stamp"]()
+ self.notify()
+ self.assertEqual(self.ns["change_stamp"](), before + 1)
+ self.assertEqual(len(self.handlers), 1)
+
+ def test_delayed_own_write_notification_does_not_look_like_a_local_copy(self):
+ self.ns["_connect"]()
+ self.ns.update(_synced_counter=0, _write_stamp=0)
+ self.own = True
+ cached_stamp = self.ns["write_stamp"]()
+ self.notify()
+ self.assertEqual(self.ns["change_stamp"](), self.ns["write_stamp"]())
+ self.assertEqual(self.ns["change_stamp"](), cached_stamp)
+ self.own = False
+ self.notify()
+ self.assertGreater(self.ns["change_stamp"](), self.ns["write_stamp"]())
+
+ def test_failed_gui_access_reports_unknown_stamp(self):
+ self.app = None
+ self.assertIsNone(self.ns["change_stamp"]())
+
+ def test_legacy_write_advances_once_with_sync_or_deferred_notifications(self):
+ self.ns["change_stamp"]()
+ for deferred in (False, True):
+ with self.subTest(deferred=deferred):
+ before = self.ns["change_stamp"]()
+ self.ns["_synced_counter"] = before
+ def publish(mime):
+ self.own = True
+ if not deferred:
+ self.notify()
+ self.clipboard.setMimeData = publish
+ written = self.ns["_write"]("remote", None)
+ self.assertTrue(written)
+ cached = self.ns["write_stamp"]()
+ self.assertEqual(cached, before + 1)
+ self.notify()
+ self.assertEqual(self.ns["change_stamp"](), cached)
+ self.own = False
+ self.notify()
+ self.assertEqual(self.ns["change_stamp"](), cached + 1)
+ self.assertEqual(self.ns["write_stamp"](), cached)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_ghlinux_devices.py b/core/tests/test_ghlinux_devices.py
new file mode 100644
index 0000000..0ace35b
--- /dev/null
+++ b/core/tests/test_ghlinux_devices.py
@@ -0,0 +1,129 @@
+"""Portal device replacement against production methods with fake input devices."""
+
+import threading
+from types import SimpleNamespace as NS
+from typing import Optional
+import unittest
+from unittest.mock import Mock
+
+import ast
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def functions(filename, names, namespace, owner=None):
+ path = ROOT / "win_app" / filename
+ body = ast.parse(path.read_text(encoding="utf-8")).body
+ if owner:
+ body = next(node.body for node in body if isinstance(node, ast.ClassDef) and node.name == owner)
+ selected = [node for node in body if isinstance(node, ast.FunctionDef) and node.name in names]
+ exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), namespace)
+ return namespace
+
+
+class PortalReplacement(unittest.TestCase):
+ def setUp(self):
+ self.now = 1.0
+ self.desktop = Mock()
+ namespace = functions("capture_portal.py", {"_ei_event", "_tick", "_signal"},
+ {"Optional": Optional, "LOGGER": Mock(), "desktop_portal": self.desktop,
+ "DISABLED_SECONDS": 0.3, "HOME_AGAIN_SECONDS": 0.5,
+ "LANDING_SECONDS": 0.1}, "Hooks")
+ hooks_type = type("Hooks", (), {name: namespace[name] for name in ("_ei_event", "_tick", "_signal")})
+ self.hooks = h = hooks_type()
+ self.pointer, self.keyboard = object(), object()
+ h._devices = {id(self.pointer), id(self.keyboard)}
+ h._leaving = set()
+ h._removed_at = None
+ h._session = NS(enabled=True)
+ h._clock = lambda: self.now
+ h._push_lock = threading.Lock()
+ h._pending_push = None
+ h._activation, h._press, h._away = 7, None, True
+ h._away_wanted = lambda: h._away
+ h._home = Mock()
+ h._home_since = h._disabled_at = h._sent_home_at = None
+ h._place_barriers = Mock()
+ h._let_go_unannounced = Mock()
+
+ def test_keyboard_replacement_across_batches_keeps_active_session(self):
+ h = self.hooks
+ h._ei_event(("device_removed", self.keyboard))
+ self.now += 0.1
+ h._tick()
+ self.assertTrue(h._session.enabled)
+ h._ei_event(("device_added", object()))
+ self.now += 1
+ h._tick()
+ self.assertTrue(h._session.enabled)
+ self.assertEqual(h._activation, 7)
+ h._home.assert_not_called()
+
+ def test_all_devices_replaced_in_next_batch_do_not_disable(self):
+ h = self.hooks
+ h._ei_event(("device_removed", self.keyboard))
+ h._ei_event(("device_removed", self.pointer))
+ self.now += 0.1
+ h._tick()
+ h._ei_event(("device_added", object()))
+ self.now += 1
+ h._tick()
+ self.assertTrue(h._session.enabled)
+ h._home.assert_not_called()
+
+ def test_replacement_window_starts_when_the_last_device_is_removed(self):
+ h = self.hooks
+ h._ei_event(("device_removed", self.keyboard))
+ self.now += 0.29
+ h._ei_event(("device_removed", self.pointer))
+ self.now += 0.02
+ h._tick()
+ self.assertTrue(h._session.enabled)
+ h._ei_event(("device_added", object()))
+ self.now += 1
+ h._tick()
+ h._home.assert_not_called()
+
+ def test_gnome_cancel_without_replacement_brings_input_home_once(self):
+ h = self.hooks
+ h._ei_event(("device_removed", self.keyboard))
+ h._ei_event(("device_removed", self.pointer))
+ self.now += 0.31
+ h._tick()
+ self.assertFalse(h._session.enabled)
+ self.assertIsNone(h._activation)
+ h._home.assert_called_once()
+ h._tick()
+ h._home.assert_called_once()
+
+ def test_expected_barrier_reconfiguration_removals_do_not_cancel(self):
+ h = self.hooks
+ h._leaving = set(h._devices)
+ h._ei_event(("device_removed", self.keyboard))
+ h._ei_event(("device_removed", self.pointer))
+ self.now += 1
+ h._tick()
+ self.assertTrue(h._session.enabled)
+ h._home.assert_not_called()
+
+ def test_explicit_disabled_still_releases_input_immediately(self):
+ h = self.hooks
+ h._expect_disabled = False
+ h._signal("Disabled", {})
+ self.assertFalse(h._session.enabled)
+ self.assertIsNone(h._activation)
+ h._home.assert_called_once()
+
+ def test_explicit_disable_clears_an_earlier_unconfirmed_removal(self):
+ h = self.hooks
+ h._expect_disabled = False
+ h._ei_event(("device_removed", self.keyboard))
+ h._ei_event(("device_removed", self.pointer))
+ h._signal("Disabled", {})
+ self.assertIsNone(h._removed_at)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/core/tests/test_i18n_coverage.py b/core/tests/test_i18n_coverage.py
index 5f14a68..ac47496 100644
--- a/core/tests/test_i18n_coverage.py
+++ b/core/tests/test_i18n_coverage.py
@@ -41,7 +41,7 @@ NOT_SHOWN = {
"Thread", "ArgumentParser", "add_argument", "setStyleSheet", "setObjectName", "setProperty",
"OpenKey", "QueryValueEx", "SetValueEx", "DeleteValue", "ExecQuery", "Dispatch", "fromData", "save",
"filterWithName_", "AXUIElementCopyAttributeValue", "AXUIElementSetAttributeValue", "NSClassFromString",
- "has_extension", "get_extension_major", "request", "call", "get_dbus_method", "dlopen", "LoadLibrary",
+ "has_extension", "get_extension_major", "request", "call", "get_dbus_method", "_signal", "dlopen", "LoadLibrary",
"run", "Popen", "check_output", "check_call", "compile", "match", "search", "sub", "fullmatch",
"get", "pop", "setdefault", "environ", "Path", "open", "write", "print",
"_warn_once", "_fail", "drop", "_connection_failed", "set_redirecting",
diff --git a/core/tests/test_mac_dead_keys.py b/core/tests/test_mac_dead_keys.py
index 4eeba60..79ed78c 100644
--- a/core/tests/test_mac_dead_keys.py
+++ b/core/tests/test_mac_dead_keys.py
@@ -149,6 +149,94 @@ class MacDeadKeyTests(unittest.TestCase):
self.assertIn("com.apple.keylayout.Spanish-ISO", found)
self.assertIn("com.apple.keylayout.German", found)
+ def test_dead_key_table_composes_layout_entries_and_falls_back_without_a_table(self):
+ self.layout.install({39: None, 50: None}, {
+ (39, 0): capture_types.DeadKey("'", {"a": "á", "c": "ç", "s": "'s"}),
+ (39, 2): capture_types.DeadKey('"', {"a": "ä", "t": '"t'}),
+ (50, 0): capture_types.DeadKey("´"),
+ (0, 0): "a", (8, 0): "c", (1, 0): "s", (17, 0): "t", (7, 0): "x", (49, 0): " ",
+ })
+ for dead, flags, base, text, want in (
+ (39, 0, 0, "a", "á"),
+ (39, 0, 8, "c", "ç"),
+ (39, 0, 1, "s", "'s"),
+ (39, 0, 7, "x", "'x"),
+ (39, 1 << 17, 0, "a", "ä"),
+ (39, 1 << 17, 17, "t", '"t'),
+ (50, 0, 0, "a", "á"),
+ (50, 0, 7, "x", "´x"),
+ ):
+ with self.subTest(dead=dead, flags=flags, base=text):
+ self.accent(dead, flags)
+ self.assertEqual(self.feed(base, text=text), [{"type": "text", "data": {"text": want}}])
+ self.feed(base, False, text=text)
+ self.accent(39)
+ self.assertEqual(self.feed(49), [{"type": "text", "data": {"text": "'"}}])
+ self.feed(49, False)
+
+ def test_layout_translations_builds_dead_key_table_after_ordinary_keys_and_skips_chained_keys(self):
+ carbon = self.layout._Carbon.__new__(self.layout._Carbon)
+ carbon.layout_data_key = 1
+ carbon.carbon = SimpleNamespace(TISGetInputSourceProperty=lambda _source, _key: 1, LMGetKbdType=lambda: 0)
+ carbon.core = SimpleNamespace(CFDataGetBytePtr=lambda data: data)
+ dead_code, a_code, c_code, s_code, chained_code = self.layout.LAYOUT_KEY_CODES[:5]
+ ordinary = {a_code: ("a", 0), c_code: ("c", 0), s_code: ("s", 0), chained_code: ("x", 0)}
+ composed = {a_code: ("á", 0), c_code: ("ç", 0), s_code: ("'s", 0), chained_code: ("", 17)}
+
+ def translate(_layout, code, _kbd_type, options, modifiers=0, dead_state=0):
+ if modifiers != 0:
+ return "", 0
+ if dead_state:
+ return composed.get(code, ("", 0))
+ if code == dead_code:
+ return ("'", 0) if options == self.layout._K_UC_KEY_TRANSLATE_NO_DEAD_KEYS else ("", 1)
+ return ordinary.get(code, ("", 0))
+
+ carbon.translate = translate
+ translations = carbon.layout_translations(1)
+ dead = translations[dead_code, 0]
+ self.assertEqual(dead.character, "'")
+ self.assertEqual(dead.compositions, {"a": "á", "c": "ç", "s": "'s"})
+
+ @unittest.skipUnless(sys.platform == "darwin", "reads installed macOS layouts without selecting them")
+ def test_us_international_dead_key_table_composes_despite_ascii_spacing(self):
+ carbon = self.layout._Carbon()
+ lib, core = carbon.carbon, carbon.core
+ lib.TISCreateInputSourceList.restype = ctypes.c_void_p
+ lib.TISCreateInputSourceList.argtypes = [ctypes.c_void_p, ctypes.c_bool]
+ core.CFArrayGetCount.restype = ctypes.c_long
+ core.CFArrayGetCount.argtypes = [ctypes.c_void_p]
+ core.CFArrayGetValueAtIndex.restype = ctypes.c_void_p
+ core.CFArrayGetValueAtIndex.argtypes = [ctypes.c_void_p, ctypes.c_long]
+ core.CFStringGetCString.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_long, ctypes.c_uint32]
+ id_key = ctypes.c_void_p.in_dll(lib, "kTISPropertyInputSourceID").value
+ sources = lib.TISCreateInputSourceList(None, True)
+ found = False
+ try:
+ for index in range(core.CFArrayGetCount(sources)):
+ source = core.CFArrayGetValueAtIndex(sources, index)
+ name_ref = lib.TISGetInputSourceProperty(source, id_key)
+ name = ctypes.create_string_buffer(256)
+ if not name_ref or not core.CFStringGetCString(name_ref, name, len(name), 0x08000100):
+ continue
+ if name.value.decode() != "com.apple.keylayout.USInternational-PC":
+ continue
+ translations = carbon.layout_translations(source)
+ self.layout.install(carbon.layout_chars(source), translations)
+ acute = next(code for (code, mods), value in translations.items()
+ if mods == 0 and isinstance(value, capture_types.DeadKey) and value.character == "'")
+ for flags, ch, want in ((0, "a", "á"), (0, "c", "ç"), (0, "s", "'s"), (1 << 17, "t", '"t')):
+ base = next(code for (code, mods), value in translations.items() if mods == 0 and value == ch)
+ self.translator.dead_keys.reset()
+ self.accent(acute, flags)
+ self.assertEqual(self.feed(base, text=ch), [{"type": "text", "data": {"text": want}}])
+ self.feed(base, False)
+ found = True
+ finally:
+ core.CFRelease(sources)
+ if not found:
+ self.skipTest("US International is not installed")
+
if __name__ == "__main__":
unittest.main()
diff --git a/core/tests/test_patch15_lock_keys.py b/core/tests/test_patch15_lock_keys.py
new file mode 100644
index 0000000..4461e7f
--- /dev/null
+++ b/core/tests/test_patch15_lock_keys.py
@@ -0,0 +1,31 @@
+"""Run the GH64 hook regressions with no native input or GUI imports."""
+
+import ast
+import ctypes
+import importlib.util
+from pathlib import Path
+import sys
+from types import SimpleNamespace as NS
+import unittest
+from unittest.mock import Mock, patch
+
+from core import keytable
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def load_tests(loader, tests, pattern):
+ spec = importlib.util.spec_from_file_location("patch15_capture", ROOT / "win_app" / "capture_win.py")
+ capture = importlib.util.module_from_spec(spec)
+ injector = NS(INJECTED_MARK=0xBEA3, SCAN_TO_US=keytable.EVDEV_US)
+ with patch.dict(sys.modules, {"input_injector": injector}):
+ spec.loader.exec_module(capture)
+ path = Path(__file__).resolve().parents[2] / "win_app" / "tests" / "test_capture_win.py"
+ body = ast.parse(path.read_text(encoding="utf-8")).body
+ selected = [node for node in body if isinstance(node, ast.ClassDef)
+ and node.name in {"HookPoint", "InjectedHookTests", "LockKeyHookTests"}]
+ ns = {"ctypes": ctypes, "unittest": unittest, "Mock": Mock, "patch": patch,
+ "capture_win": capture, "INJECTED_MARK": 0xBEA3}
+ exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), ns)
+ return loader.loadTestsFromTestCase(ns["LockKeyHookTests"])
diff --git a/core/tests/test_patch15_nearby.py b/core/tests/test_patch15_nearby.py
new file mode 100644
index 0000000..e40b50a
--- /dev/null
+++ b/core/tests/test_patch15_nearby.py
@@ -0,0 +1,67 @@
+"""Exercise native refresh invalidation without importing AppKit or opening a window."""
+
+import ast
+from pathlib import Path
+from types import SimpleNamespace as NS
+import unittest
+from unittest.mock import Mock
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+class NearbyRefresh(unittest.TestCase):
+ def setUp(self):
+ path = ROOT / "mac_app" / "machines_panel.py"
+ body = ast.parse(path.read_text(encoding="utf-8")).body
+ owner = next(node for node in body if isinstance(node, ast.ClassDef) and node.name == "MachinesPanel")
+ method = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_refresh_nearby")
+ self.rows, self.labels = [], []
+ def row(*args, **kwargs):
+ result = Mock()
+ self.rows.append(result)
+ return result
+ def label(*args, **kwargs):
+ result = Mock()
+ self.labels.append(result)
+ return result
+ ns = {"tr": lambda text: text, "seconds": str, "grouped": lambda text: text,
+ "pairing": NS(CODE_DIGITS=6), "machines": NS(platform_name=lambda name: name),
+ "AppKit": NS(NSAccessibilityRadioButtonRole="radio"),
+ "theme": NS(TYPE={"note": 12}), "widgets": NS(pressable=row, Label=label, pin=Mock())}
+ exec(compile(ast.Module(body=[method], type_ignores=[]), str(path), "exec"), ns)
+ self.refresh = ns["_refresh_nearby"]
+ self.panel = p = NS(service=NS(nearby_status={"state": "choosing", "peers": [
+ {"name": "Test PC", "platform": "Windows", "address": "192.0.2.40"}]}),
+ controller=NS(cfg=NS(hide_addresses=False)), _nearby_key=None,
+ _nearby_widgets=Mock(), _shown=lambda value: value)
+ for name in ("nearby_status_label", "nearby_expiry", "nearby_sas", "nearby_peer_label",
+ "nearby_confirm", "nearby_cancel", "nearby_view", "nearby_choices"):
+ setattr(p, name, Mock())
+ p.nearby_choices.arrangedSubviews.return_value = []
+
+ def test_first_candidate_invalidates_label_and_row_then_lays_out_the_subtree(self):
+ self.refresh(self.panel)
+ self.assertEqual(len(self.rows), 1)
+ self.labels[0].view.setNeedsDisplay_.assert_called_once_with(True)
+ self.rows[0].setNeedsLayout_.assert_called_once_with(True)
+ self.rows[0].setNeedsDisplay_.assert_called_once_with(True)
+ self.panel.nearby_choices.setNeedsLayout_.assert_called_once_with(True)
+ self.panel.nearby_view.setNeedsLayout_.assert_called_once_with(True)
+ self.panel.nearby_view.layoutSubtreeIfNeeded.assert_called_once_with()
+
+ def test_unchanged_candidates_do_not_rebuild_or_relayout(self):
+ self.refresh(self.panel)
+ self.refresh(self.panel)
+ self.assertEqual(len(self.rows), 1)
+ self.panel.nearby_view.layoutSubtreeIfNeeded.assert_called_once_with()
+
+ def test_expiry_clears_choices_and_relayouts(self):
+ self.refresh(self.panel)
+ self.panel.service.nearby_status = {"state": "expired"}
+ self.refresh(self.panel)
+ self.assertEqual(self.panel.nearby_view.layoutSubtreeIfNeeded.call_count, 2)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/flatpak/uk.co.kalkman.beamer.metainfo.xml b/flatpak/uk.co.kalkman.beamer.metainfo.xml
index 0ae0be3..c761c82 100644
--- a/flatpak/uk.co.kalkman.beamer.metainfo.xml
+++ b/flatpak/uk.co.kalkman.beamer.metainfo.xml
@@ -43,6 +43,9 @@
</screenshots>
<content_rating type="oars-1.1"/>
<releases>
+ <release version="1.5.19" date="2026-11-03">
+ <description><p>Fixes shortcuts such as Ctrl+A when Caps Lock differs between machines, keeps input working when a Wayland input device is replaced, detects new X11 clipboard copies, and installs its input library where Flatpak loads it. When a Mac on U.S. International controls another machine, dead keys now compose accents, such as ' then e for é. On a busy Wayland receiver, Beamer now keeps pointer movement it used to drop, so the pointer is less likely to stick at the screen edge.</p></description>
+ </release>
<release version="1.5.18" date="2026-10-29">
<description><p>When another machine controls a Windows PC that has no mouse plugged in, Windows draws no pointer there, so Beamer now draws its own while you control that PC. The PC being controlled needs 1.5.18 for this.</p></description>
</release>
diff --git a/mac_app/keyboard_layout.py b/mac_app/keyboard_layout.py
index bc5f481..7a976a9 100644
--- a/mac_app/keyboard_layout.py
+++ b/mac_app/keyboard_layout.py
@@ -105,8 +105,8 @@ class _Carbon:
core.CFRelease.argtypes = [ctypes.c_void_p]
self.layout_data_key = ctypes.c_void_p.in_dll(carbon, "kTISPropertyUnicodeKeyLayoutData").value
- def translate(self, layout, keycode, kbd_type, options, modifiers=0):
- dead = ctypes.c_uint32(0)
+ def translate(self, layout, keycode, kbd_type, options, modifiers=0, dead_state=0):
+ dead = ctypes.c_uint32(dead_state)
length = ctypes.c_ulong(0)
buffer = (ctypes.c_uint16 * 8)()
status = self.carbon.UCKeyTranslate(
@@ -152,15 +152,24 @@ class _Carbon:
layout = self.core.CFDataGetBytePtr(data)
kbd_type = self.carbon.LMGetKbdType()
translations = {}
+ dead_keys = []
for modifiers in (0, 1, 2, 3, 8, 9, 10, 11):
for code in (*LAYOUT_KEY_CODES, 0x31):
text, dead = self.translate(layout, code, kbd_type, 0, modifiers)
if dead:
- text, _ = self.translate(layout, code, kbd_type, _K_UC_KEY_TRANSLATE_NO_DEAD_KEYS, modifiers)
- if text and len(text) == 1:
- translations[code, modifiers] = DeadKey(text)
+ spacing, _ = self.translate(layout, code, kbd_type, _K_UC_KEY_TRANSLATE_NO_DEAD_KEYS, modifiers)
+ if spacing and len(spacing) == 1:
+ dead_keys.append((code, modifiers, spacing, dead))
elif text and len(text) == 1 and text.isprintable():
translations[code, modifiers] = text
+ ordinary = list(translations.items())
+ for code, modifiers, spacing, dead in dead_keys:
+ compositions = {}
+ for (base_code, base_modifiers), base in ordinary:
+ composed, _ = self.translate(layout, base_code, kbd_type, 0, base_modifiers, dead)
+ if composed:
+ compositions.setdefault(base, composed)
+ translations[code, modifiers] = DeadKey(spacing, compositions)
return translations
def current_translations(self):
diff --git a/mac_app/machines_panel.py b/mac_app/machines_panel.py
index 4e60a1c..9eb0143 100644
--- a/mac_app/machines_panel.py
+++ b/mac_app/machines_panel.py
@@ -652,6 +652,12 @@ class MachinesPanel:
row.addSubview_(text.view)
widgets.pin(text.view, row, (7, 10, 7, 10))
self.nearby_choices.addArrangedSubview_(row)
+ text.view.setNeedsDisplay_(True)
+ row.setNeedsLayout_(True)
+ row.setNeedsDisplay_(True)
+ self.nearby_choices.setNeedsLayout_(True)
+ self.nearby_view.setNeedsLayout_(True)
+ self.nearby_view.layoutSubtreeIfNeeded()
sas = status.get("sas") if state in {"confirm", "waiting"} else None
valid_sas = isinstance(sas, str) and len(sas) == pairing.CODE_DIGITS and sas.isascii() and sas.isdigit()
diff --git a/mac_app/tests/test_input_injector_mac.py b/mac_app/tests/test_input_injector_mac.py
index 3d52bd5..ec68b7b 100644
--- a/mac_app/tests/test_input_injector_mac.py
+++ b/mac_app/tests/test_input_injector_mac.py
@@ -57,6 +57,21 @@ class KeyPlanTests(unittest.TestCase):
mods = {"cmd"}
self.assertEqual(injector.plan_key_event("c", True, mods), (0x08, None))
+ def test_caps_capitals_keep_chord_keys_and_plain_text_in_each_script(self):
+ for lower in ("c", "ф", "ω"):
+ with mock.patch.object(injector.keyboard_layout, "code_for", side_effect=lambda ch: 0x08 if ch == lower else None):
+ upper = lower.upper()
+ self.assertEqual(self.plan(upper), (0, upper))
+ for modifier in sorted(injector.CHORD_MODIFIERS):
+ for shifted in (False, True):
+ with self.subTest(character=upper, modifier=modifier, shifted=shifted):
+ mods = {modifier} | ({"shift"} if shifted else set())
+ held = {}
+ self.assertEqual(injector.plan_key_event(upper, True, mods, held), (0x08, None))
+ mods.clear()
+ self.assertEqual(injector.plan_key_event(upper, False, mods, held), (0x08, None))
+ self.assertEqual(held, {})
+
def test_a_character_off_the_table_is_typed_as_text(self):
self.assertEqual(self.plan("é"), (0, "é"))
diff --git a/mac_app/tests/test_widgets.py b/mac_app/tests/test_widgets.py
index 9332e44..79eeb2b 100644
--- a/mac_app/tests/test_widgets.py
+++ b/mac_app/tests/test_widgets.py
@@ -17,6 +17,26 @@ import widgets
class WidthTests(unittest.TestCase):
+ def test_action_survives_when_only_the_native_button_is_retained(self):
+ import objc
+
+ calls = []
+ with objc.autorelease_pool():
+ button = widgets.action_button("Send input", lambda: calls.append("sent"))
+ view = button.view
+ target = objc.WeakRef(button.target)
+ del button
+ gc.collect()
+ with objc.autorelease_pool():
+ self.assertIsNotNone(target())
+ self.assertTrue(view.sendAction_to_(view.action(), view.target()))
+ self.assertEqual(calls, ["sent"])
+ with objc.autorelease_pool():
+ del view
+ gc.collect()
+ with objc.autorelease_pool():
+ self.assertIsNone(target())
+
def test_idle_design_lock_does_not_redraw_unchanged_choices(self):
import objc
diff --git a/mac_app/widgets.py b/mac_app/widgets.py
index 5029847..d0ac49b 100644
--- a/mac_app/widgets.py
+++ b/mac_app/widgets.py
@@ -816,6 +816,8 @@ def action_button(title, callback, **options):
target = callback_target(callback)
button = Button(title, target, "fire:", **options)
button.target = target
+ # Many callers retain only the native view; NSControl's target is weak.
+ objc.setAssociatedObject(button.view, "widgets.action_target", target)
return button
diff --git a/uk.co.kalkman.beamer.json b/uk.co.kalkman.beamer.json
index 5d734c7..cf4bc61 100644
--- a/uk.co.kalkman.beamer.json
+++ b/uk.co.kalkman.beamer.json
@@ -43,7 +43,7 @@
{
"name": "libei",
"buildsystem": "meson",
- "config-opts": ["-Dtests=disabled", "-Dliboeffis=disabled", "-Dlibeis=disabled", "-Ddocumentation=[]"],
+ "config-opts": ["--libdir=lib", "-Dtests=disabled", "-Dliboeffis=disabled", "-Dlibeis=disabled", "-Ddocumentation=[]"],
"sources": [{
"type": "archive",
"url": "https://gitlab.freedesktop.org/libinput/libei/-/archive/1.6.0/libei-1.6.0.tar.bz2",
diff --git a/win_app/capture_portal.py b/win_app/capture_portal.py
index cba1c26..4923ff6 100644
--- a/win_app/capture_portal.py
+++ b/win_app/capture_portal.py
@@ -450,6 +450,7 @@ class Hooks:
self._reject_unannounced = False
self._sequences: Dict[object, int] = {} # libei device: the sequence it emulates under
self._disabled_at: Optional[float] = None
+ self._removed_at: Optional[float] = None
self._expect_disabled = False # Beamer's own SetPointerBarriers on an enabled session, whose Disabled is to come
self._devices = set() # ids of the captured devices the desktop has added and not removed
self._leaving = set() # of those, the ones a disable Beamer knows of is about to remove
@@ -673,6 +674,7 @@ class Hooks:
if point is not None:
desktop_portal.note_position(*point)
if member == "Disabled":
+ self._removed_at = None
self._session.enabled = False
self._disabled_at = self._clock()
if self._expect_disabled:
@@ -688,6 +690,7 @@ class Hooks:
self._home()
elif member == "ZonesChanged":
# Mutter and KWin disable the session on a monitor change; mutter says only this.
+ self._removed_at = None
self._session.enabled = False
self._leaving = set(self._devices)
self._set_zones(self._session.zones())
@@ -861,6 +864,13 @@ class Hooks:
except Exception:
LOGGER.exception("The shortcut push failure callback failed")
session = self._session
+ if self._removed_at is not None and self._clock() - self._removed_at >= DISABLED_SECONDS:
+ self._removed_at = None
+ if not self._devices and session is not None and session.enabled:
+ LOGGER.info("The desktop removed all capture devices; enabling the session again")
+ self._signal("Deactivated", {})
+ session.enabled = False
+ self._disabled_at = self._clock()
if self._activation is None:
# Input away with nothing captured (a switch that passed input_held() just before a
# let-go): no key can reach the peer, so it comes home.
@@ -945,6 +955,7 @@ class Hooks:
kind = event[0]
if kind == "device_added":
device = event[1]
+ self._removed_at = None
self._devices.add(id(device))
self._leaving.discard(id(device))
if hasattr(device, "keymap") and 4 in getattr(device, "caps", ()): # libei.CAP_KEYBOARD
@@ -956,13 +967,10 @@ class Hooks:
self._devices.discard(id(event[1]))
if id(event[1]) in self._leaving:
self._leaving.discard(id(event[1]))
- elif self._session is not None and self._session.enabled:
- # Mutter's cancel shortcut leaves the session disabled and says nothing but this:
- # a release only stops the devices, a disable removes them. Its barriers stand, so
- # Enable alone brings the edges back.
- LOGGER.info("The desktop removed the capture's input devices; enabling the session again")
- self._session.enabled = False
- self._disabled_at = self._clock()
+ elif not self._devices and self._session is not None and self._session.enabled:
+ # Input methods replace devices too; only sustained loss of every device implies cancel.
+ if self._removed_at is None:
+ self._removed_at = self._clock()
return
if kind == "device_paused":
device = event[1]
diff --git a/win_app/capture_win.py b/win_app/capture_win.py
index aa26523..c87e5c4 100644
--- a/win_app/capture_win.py
+++ b/win_app/capture_win.py
@@ -538,6 +538,7 @@ class Hooks:
self._thread_id: Optional[int] = None
self._ready = threading.Event()
self._state = KeyboardState()
+ self._injected_caps_down = False
self._dead_keys_swallowed: Set[int] = set()
self._text_keyups_swallowed: Set[int] = set()
self._key_names: Dict[Tuple[int, bool, Optional[int]], Tuple[str, Optional[str]]] = {}
@@ -624,6 +625,7 @@ class Hooks:
if not self._desktop_hook:
raise RuntimeError("Could not monitor Windows input desktop changes")
self._state.caps_lock = read_caps_lock()
+ self._injected_caps_down = False
self._ready.set()
message = MSG()
while user32.GetMessageW(ctypes.byref(message), None, 0, 0) > 0:
@@ -690,6 +692,11 @@ class Hooks:
try:
data = ctypes.cast(lparam, ctypes.POINTER(KBDLLHOOKSTRUCT)).contents
if data.flags & LLKHF_INJECTED and data.dwExtraInfo == INJECTED_MARK:
+ if data.vkCode == VK_CAPITAL:
+ down = wparam in KEY_DOWN_MESSAGES
+ if down and not self._injected_caps_down:
+ self._state.caps_lock = not self._state.caps_lock
+ self._injected_caps_down = down
return user32.CallNextHookEx(None, code, wparam, lparam)
down = wparam in KEY_DOWN_MESSAGES
if not down and wparam not in KEY_UP_MESSAGES:
@@ -699,8 +706,6 @@ class Hooks:
return user32.CallNextHookEx(None, code, wparam, lparam)
if data.vkCode in (0xA0, 0xA1, 0x10): # noqa: shift, either side
self._state.shift_down = down
- elif data.vkCode == VK_CAPITAL and down:
- self._state.caps_lock = not self._state.caps_lock
elif data.vkCode == 0xA5:
self._state.altgr_down = down
elif data.vkCode in (0x11, 0xA2, 0xA3) and data.scanCode != 0x21D:
@@ -774,6 +779,9 @@ class Hooks:
self._key_names[physical] = (name, us)
if self._on_key(name, down, data.vkCode, us):
return 1
+ if data.vkCode == VK_CAPITAL and down:
+ # Only an accepted first press changes this PC; swallowed presses belong to its peer.
+ self._state.caps_lock = not self._state.caps_lock
except Exception:
# Never let an exception here swallow a key: fail open, log once
# per event, and let Windows have it.
diff --git a/win_app/clipboard_x11.py b/win_app/clipboard_x11.py
index 7e4255f..23cac24 100644
--- a/win_app/clipboard_x11.py
+++ b/win_app/clipboard_x11.py
@@ -32,6 +32,7 @@ TIMEOUT_SECONDS = 2.0
# on every switch.
_change_counter = 0
_synced_counter = None
+_write_stamp = None
_own_token = 0
_connected_to = None
@@ -111,13 +112,11 @@ def _is_own_write(clipboard) -> bool:
def _on_data_changed() -> None:
- global _change_counter, _synced_counter
- was_synced = _synced_counter == _change_counter
+ global _change_counter
+ # A deferred own notification must not invalidate the stamp already cached by a caller.
+ if _synced_counter == _change_counter and _is_own_write(QGuiApplication.clipboard()):
+ return
_change_counter += 1
- # dataChanged may be delivered during setMimeData or later from the event loop: _write covers
- # the first, this covers the second, carrying the marker forward only if nothing else changed.
- if was_synced and _is_own_write(QGuiApplication.clipboard()):
- _synced_counter = _change_counter
def _connect() -> None:
@@ -166,8 +165,21 @@ def _changed() -> Tuple[Optional[str], Optional[bytes]]:
return text, png
+def _stamp():
+ _connect()
+ return _change_counter
+
+
+def change_stamp():
+ return _on_gui(_stamp, default=None)
+
+
+def write_stamp():
+ return _write_stamp
+
+
def _write(text: Optional[str], png: Optional[bytes]) -> bool:
- global _own_token, _synced_counter
+ global _own_token, _synced_counter, _write_stamp, _change_counter
_connect()
mime = QMimeData()
if text is not None:
@@ -177,8 +189,12 @@ def _write(text: Optional[str], png: Optional[bytes]) -> bool:
mime.setData(PNG_MIME, png)
_own_token += 1
mime.setData(OWN_FORMAT, str(_own_token).encode())
+ before = _change_counter
QGuiApplication.clipboard().setMimeData(mime)
+ if _change_counter == before:
+ _change_counter += 1
_synced_counter = _change_counter
+ _write_stamp = _change_counter
return True
diff --git a/win_app/inject_portal.py b/win_app/inject_portal.py
index d3703d9..d101d8b 100644
--- a/win_app/inject_portal.py
+++ b/win_app/inject_portal.py
@@ -165,6 +165,18 @@ def _libei_present() -> None:
_ei_sender.preflight = _libei_present
+class _QueuedMove:
+ def __init__(self, dx: int, dy: int) -> None:
+ self.dx, self.dy = dx, dy
+
+ def add(self, dx: int, dy: int) -> None:
+ self.dx += dx
+ self.dy += dy
+
+ def __call__(self, session) -> None:
+ session.move_by(self.dx, self.dy)
+
+
class Remote:
"""The RemoteDesktop session's thread. `submit(fn)` runs fn(self) there once the desktop's
devices are up; `ask(fn)` runs it there at once and returns its answer.
@@ -180,6 +192,7 @@ class Remote:
self._keymap = keymap or _keymap_from_text
self._tokens = tokens or portal.TokenStore("remote-desktop")
self._commands: "queue.Queue" = queue.Queue()
+ self._enqueue_lock = threading.Lock()
self._wake_read, self._wake_write = os.pipe()
os.set_blocking(self._wake_read, False)
os.set_blocking(self._wake_write, False)
@@ -274,16 +287,42 @@ class Remote:
if not self._admits():
return
self.start()
- if self._commands.qsize() >= MAX_PENDING and not release:
- if not self._said_full:
- self._said_full = True
- LOGGER.warning("Remote control is not keeping up; input from the peer is dropped until it does")
- return
- self._said_full = False
thread = self._thread
if thread is None or not thread.is_alive():
return # between sessions: input that late would play stale
- self._commands.put((work, None, None))
+ with self._enqueue_lock:
+ if self._commands.qsize() >= MAX_PENDING and not release:
+ if not self._said_full:
+ self._said_full = True
+ LOGGER.warning("Remote control is not keeping up; input from the peer is dropped until it does")
+ return
+ self._said_full = False
+ self._commands.put((work, None, None))
+ self._wake()
+
+ def submit_move(self, dx: int, dy: int) -> None:
+ if not self._admits():
+ return
+ self.start()
+ thread = self._thread
+ if thread is None or not thread.is_alive():
+ return
+ move = _QueuedMove(dx, dy)
+ with self._enqueue_lock:
+ if self._commands.qsize() >= MAX_PENDING:
+ with self._commands.mutex:
+ queued = self._commands.queue
+ marker = queued[-1][2] if queued else None
+ if isinstance(marker, _QueuedMove):
+ marker.add(dx, dy)
+ self._said_full = False
+ return
+ if not self._said_full:
+ self._said_full = True
+ LOGGER.warning("Remote control is not keeping up; input from the peer is dropped until it does")
+ return
+ self._said_full = False
+ self._commands.put((move, None, move))
self._wake()
def ask(self, work: Callable[["Remote"], object], default=None, timeout: float = CALL_SECONDS,
@@ -796,7 +835,7 @@ def inject_text(text: str) -> None:
def inject_mouse_move(dx: int, dy: int) -> None:
- remote().submit(lambda session: session.move_by(dx, dy))
+ remote().submit_move(dx, dy)
def move_to(x: int, y: int) -> None:
diff --git a/win_app/input_injector.py b/win_app/input_injector.py
index 6f44aad..d7e35e6 100644
--- a/win_app/input_injector.py
+++ b/win_app/input_injector.py
@@ -412,7 +412,8 @@ def plan_key_inputs(
vk = result & 0xFF
shift_state = (result >> 8) & 0xFF
shift_only = shift_state == 0x01
- if shift_state == 0 or (shift_only and mods_down & SHIFT_KEYS):
+ # Chords need the real key; Caps Lock's character case must not imply a held Shift.
+ if mods_down & CHORD_KEYS or shift_state == 0 or (shift_only and mods_down & SHIFT_KEYS):
scan = scan_lookup(vk)
char_vk_down[ch] = vk
return [(vk, scan, keyup_flag)]
diff --git a/win_app/sender.py b/win_app/sender.py
index 07cd03e..9a91be9 100644
--- a/win_app/sender.py
+++ b/win_app/sender.py
@@ -823,7 +823,9 @@ class LinkSender:
It runs while a peer is driving this PC too. Every move a peer makes here carries
INJECTED_MARK and never arrives, so what does is this PC's own mouse, and its push out
means the pointer is going on with this mouse behind it."""
- if ((self._home_hold is not None and self._home_hold.blocks(self._clock()))
+ # Wayland barriers also capture injected motion; the receiver owns crossing during a visit.
+ if ((self.push_out is not None and self.driven())
+ or (self._home_hold is not None and self._home_hold.blocks(self._clock()))
or not self._models or self.edges_held or self._owner is None):
return
if self._buttons_held and self._setting("block_while_dragging", True) and self._still_dragging():
@@ -875,7 +877,7 @@ class LinkSender:
"""The models of this PC's ways out, where a desktop that captures input at barriers puts
them; none while the edges are held."""
with self._lock:
- if self.edges_held or self._owner is None:
+ if self.edges_held or self._owner is None or (self.push_out is not None and self.driven()):
return []
return [model for _peer, model in self._models]
diff --git a/win_app/tests/test_capture_win.py b/win_app/tests/test_capture_win.py
index 118a1f8..7214d52 100644
--- a/win_app/tests/test_capture_win.py
+++ b/win_app/tests/test_capture_win.py
@@ -440,6 +440,69 @@ class TriggerTests(unittest.TestCase):
self.assertEqual(trigger.feed("alt_r", True, 1.0), REDIRECT)
+class LockKeyHookTests(unittest.TestCase):
+ HookData = InjectedHookTests.HookData
+
+ def key(self, hooks, vk, down, native, injected=False):
+ data = self.HookData(vk, 0x3A if vk == 0x14 else 0x45,
+ capture_win.LLKHF_INJECTED if injected else 0, 0,
+ INJECTED_MARK if injected else 0)
+
+ def accept(_handle, _code, _message, _data):
+ if down and vk not in native["down"]:
+ native[vk] = not native[vk]
+ if down:
+ native["down"].add(vk)
+ else:
+ native["down"].discard(vk)
+ return 99
+
+ with patch.object(capture_win, "KBDLLHOOKSTRUCT", self.HookData, create=True), \
+ patch.object(capture_win, "user32", Mock(CallNextHookEx=accept)):
+ return hooks._keyboard_proc(capture_win.HC_ACTION,
+ capture_win.WM_KEYDOWN if down else capture_win.WM_KEYUP, ctypes.byref(data))
+
+ def test_remote_lock_presses_change_only_the_recipient_and_its_translation_state(self):
+ source_native = {0x14: False, 0x90: True, "down": set()}
+ target_native = {0x14: True, 0x90: False, "down": set()}
+ target_key = Mock(return_value=False)
+ target = capture_win.Hooks(target_key, Mock(), Mock())
+ target._state.caps_lock = True
+
+ def forward(_name, down, vk, _us):
+ self.key(target, vk, down, target_native, injected=True)
+ return True
+
+ source = capture_win.Hooks(forward, Mock(), Mock())
+ for vk in (0x14, 0x90):
+ for down in (True, True, False):
+ self.assertEqual(self.key(source, vk, down, source_native), 1)
+ self.assertFalse(source_native[0x14])
+ self.assertTrue(source_native[0x90])
+ self.assertFalse(target_native[0x14])
+ self.assertTrue(target_native[0x90])
+ self.assertFalse(source._state.caps_lock)
+ self.assertFalse(target._state.caps_lock)
+ target_key.assert_not_called()
+
+ def test_local_caps_lock_changes_once_per_press_and_survives_a_swallowed_press(self):
+ native = {0x14: False, "down": set()}
+ on_key = Mock(return_value=False)
+ hooks = capture_win.Hooks(on_key, Mock(), Mock())
+ for down in (True, True, True, False):
+ self.assertEqual(self.key(hooks, 0x14, down, native), 99)
+ self.assertEqual(hooks._state.caps_lock, native[0x14])
+ on_key.return_value = True
+ for down in (True, True, False):
+ self.key(hooks, 0x14, down, native)
+ self.assertEqual(hooks._state.caps_lock, native[0x14])
+ on_key.return_value = False
+ for down in (True, False):
+ self.key(hooks, 0x14, down, native)
+ self.assertFalse(hooks._state.caps_lock)
+ self.assertFalse(native[0x14])
+
+
class HandMotionTests(unittest.TestCase):
"""What the WM_INPUT reader keeps. Raw Input reports a SendInput move
exactly as it reports the mouse, so the injector's stamp is the only
diff --git a/win_app/tests/test_inject_portal.py b/win_app/tests/test_inject_portal.py
index b1c1888..7d0dfdb 100644
--- a/win_app/tests/test_inject_portal.py
+++ b/win_app/tests/test_inject_portal.py
@@ -48,6 +48,19 @@ class FakeKeymap:
class StepsTest(unittest.TestCase):
+ def test_caps_capitals_keep_wayland_chord_keycodes(self):
+ for locks in (0, 2):
+ for modifier in ("ctrl", "alt", "cmd"):
+ with self.subTest(locks=locks, modifier=modifier):
+ state = inject_portal.KeyState()
+ state.mods_down.add(modifier)
+ layout = inject_portal.WaylandLayout(FakeKeymap())
+ down = inject_portal.plan_key("A", True, None, state, layout, 0, locks)
+ state.mods_down.clear()
+ up = inject_portal.plan_key("A", False, None, state, layout, 0, locks)
+ self.assertEqual(inject_portal.wayland_steps(down), [(30, True)])
+ self.assertEqual(inject_portal.wayland_steps(up), [(30, False)])
+
def test_input_method_names_press_and_release_evdev_122_and_123(self):
for name, code in (("hangul", 122), ("hanja", 123)):
with self.subTest(name=name):
@@ -532,6 +545,32 @@ class RemoteTest(unittest.TestCase):
inject_portal.MAX_PENDING = saved
self.assertEqual([item[2:] for item in self.ei.sends("key")], [(29, True), (29, False)])
+ def test_a_full_queue_keeps_the_mouse_motion_that_leaves_the_edge(self):
+ saved = inject_portal.MAX_PENDING
+ self.remote._thread = threading.current_thread()
+ inject_portal.MAX_PENDING = 1
+ try:
+ inject_portal.inject_mouse_move(3, 0)
+ inject_portal.inject_mouse_move(5, 0)
+
+ self.assertEqual(self.remote._commands.qsize(), 1)
+ work, answer, _marker = self.remote._commands.get_nowait()
+ self.assertIsNone(answer)
+
+ class Pointer:
+ def __init__(self):
+ self.moves = []
+
+ def move_by(self, dx, dy):
+ self.moves.append((dx, dy))
+
+ pointer = Pointer()
+ work(pointer)
+ self.assertEqual(pointer.moves, [(8, 0)])
+ finally:
+ self.remote._thread = None
+ inject_portal.MAX_PENDING = saved
+
def test_a_missing_library_is_said_once_and_never_retried(self):
def missing():
raise RuntimeError("libei is not installed; Beamer needs it to capture and play input on Wayland")
diff --git a/win_app/tests/test_inject_x11.py b/win_app/tests/test_inject_x11.py
index 76c1334..ad5f5f2 100644
--- a/win_app/tests/test_inject_x11.py
+++ b/win_app/tests/test_inject_x11.py
@@ -137,6 +137,21 @@ class CharacterTest(unittest.TestCase):
self.assertEqual(plan("a", locks=CAPS), [(NO_REPEAT, A), (PRESS, SHIFT_L), (PRESS, A), (RELEASE, SHIFT_L)])
self.assertEqual(plan("!", locks=CAPS), [(NO_REPEAT, ONE), (PRESS, SHIFT_L), (PRESS, ONE), (RELEASE, SHIFT_L)])
+ def test_caps_capitals_keep_chord_keys_in_latin_and_non_latin_layouts(self):
+ for character, group in (("A", 0), ("Ф", 1)):
+ for locks in (0, CAPS):
+ for modifier in sorted(inject_x11.CHORD_KEYS):
+ for shifted in (False, True):
+ with self.subTest(character=character, locks=locks, modifier=modifier, shifted=shifted):
+ state = KeyState()
+ plan(modifier, state=state)
+ if shifted:
+ plan("shift", state=state)
+ self.assertEqual(plan(character, state=state, group=group, locks=locks), [(PRESS, A)])
+ state.mods_down.clear()
+ self.assertEqual(plan(character, down=False, state=state, group=group, locks=locks), [(RELEASE, A)])
+ self.assertEqual(state.chars_down, {})
+
def test_under_a_chord_shift_is_the_peer_s(self):
state = KeyState()
plan("ctrl", state=state)
diff --git a/win_app/tests/test_input_injector.py b/win_app/tests/test_input_injector.py
index d396254..c65cad8 100644
--- a/win_app/tests/test_input_injector.py
+++ b/win_app/tests/test_input_injector.py
@@ -23,7 +23,7 @@ FAKE_VK_SCAN = {
"C": 0x0143, # shift + VK_C (upper-case via shift)
"k": 0x004B, # plain, no shift needed
"K": 0x014B, # shift + VK_K (upper-case via shift)
- "@": 0x0602, # requires ctrl+alt (AltGr) bits -> unsupported combo
+ "@": 0x0632, # requires ctrl+alt (AltGr) bits
}
# Fake MapVirtualKeyW: vk -> hardware scan code.
@@ -31,6 +31,7 @@ FAKE_SCAN_CODES = {
0x43: 0x2E, # 'C' key
0x45: 0x12, # 'E' key
0x4B: 0x25, # 'K' key
+ 0x32: 0x03, # '2' key
0x0D: 0x1C, # enter
0x26: 0x48, # up arrow
0xA3: 0x1D, # ctrl_r
@@ -139,15 +140,13 @@ class PlanKeyInputsChordTests(unittest.TestCase):
self.assertEqual(up_plan, [(0, ord("a"), KEYEVENTF_UNICODE | KEYEVENTF_KEYUP)])
self.assertEqual(char_vk_down, {})
- def test_altgr_char_falls_back_to_unicode(self):
+ def test_chord_uses_the_real_key_even_when_translation_needs_altgr(self):
mods_down = {"ctrl"}
char_vk_down = {}
- with self.assertLogs("input_injector", level="WARNING"):
- down_plan = plan_key_inputs("@", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
-
- self.assertEqual(down_plan, [(0, ord("@"), KEYEVENTF_UNICODE)])
- self.assertEqual(char_vk_down, {})
+ down_plan = plan_key_inputs("@", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
+ self.assertEqual(down_plan, [(0x32, 0x03, 0)])
+ self.assertEqual(char_vk_down, {"@": 0x32})
def test_unresolvable_char_falls_back_to_unicode(self):
mods_down = {"alt"}
@@ -160,10 +159,6 @@ class PlanKeyInputsChordTests(unittest.TestCase):
self.assertEqual(char_vk_down, {})
def test_shift_only_vk_scan_result_adds_no_synthetic_shift(self):
- # Ctrl+Shift+C: the chord modifier alone doesn't satisfy a
- # shift-only VkKeyScanW result -- shift must actually be held too
- # (it is here), and when it is, no extra synthetic shift keydown is
- # injected on top of the real VK+scan keystroke.
mods_down = {"ctrl", "shift"}
char_vk_down = {}
@@ -171,17 +166,69 @@ class PlanKeyInputsChordTests(unittest.TestCase):
self.assertEqual(down_plan, [(0x43, 0x2E, 0)])
self.assertEqual(char_vk_down, {"C": 0x43})
- def test_shift_only_result_without_shift_held_falls_back_even_with_a_chord(self):
- # A chord modifier being held is not enough on its own: Ctrl+C
- # where "C" only resolves via a shift bit that isn't actually down
- # (e.g. caps-lock) must not be sent as the plain 'c' VK -- that
- # would silently turn Ctrl+Shift+C into Ctrl+C on Windows.
- mods_down = {"ctrl"}
- char_vk_down = {}
-
- down_plan = plan_key_inputs("C", True, mods_down, char_vk_down, fake_vk_lookup, fake_scan_lookup)
- self.assertEqual(down_plan, [(0, ord("C"), KEYEVENTF_UNICODE)])
- self.assertEqual(char_vk_down, {})
+ def test_caps_capital_keeps_the_real_chord_key_and_the_forwarded_shift(self):
+ for modifier in sorted(input_injector.CHORD_KEYS):
+ for shifted in (False, True):
+ for character in ("C", "Ф", "Ω"):
+ with self.subTest(modifier=modifier, shifted=shifted, character=character):
+ mods = {modifier} | ({"shift_r"} if shifted else set())
+ held = {}
+ lookup = lambda ch: 0x0143
+ expected_mods = set(mods)
+ self.assertEqual(plan_key_inputs(character, True, mods, held, lookup, fake_scan_lookup),
+ [(0x43, 0x2E, 0)])
+ self.assertEqual(mods, expected_mods)
+ self.assertEqual(plan_key_inputs(character, True, mods, held, lambda ch: -1, fake_scan_lookup),
+ [(0x43, 0x2E, 0)])
+ mods.clear()
+ self.assertEqual(plan_key_inputs(character, False, mods, held, lambda ch: -1, fake_scan_lookup),
+ [(0x43, 0x2E, KEYEVENTF_KEYUP)])
+ self.assertEqual(held, {})
+
+ def test_plain_non_latin_caps_capital_stays_unicode(self):
+ for character in ("Ф", "Ω"):
+ with self.subTest(character=character):
+ held = {}
+ self.assertEqual(plan_key_inputs(character, True, set(), held, lambda ch: 0x0143, fake_scan_lookup),
+ [(0, ord(character), KEYEVENTF_UNICODE)])
+ self.assertEqual(plan_key_inputs(character, False, set(), held, lambda ch: -1, fake_scan_lookup),
+ [(0, ord(character), KEYEVENTF_UNICODE | KEYEVENTF_KEYUP)])
+ self.assertEqual(held, {})
+
+ def test_chord_from_another_script_uses_its_physical_place(self):
+ for modifier in sorted(input_injector.CHORD_KEYS):
+ with self.subTest(modifier=modifier):
+ held = {}
+ args = (held, lambda ch: -1, fake_scan_lookup, "c", lambda us: (0x43, "c"))
+ self.assertEqual(plan_key_inputs("Ф", True, {modifier}, *args), [(0x43, 0x2E, 0)])
+ self.assertEqual(plan_key_inputs("Ф", False, set(), *args), [(0x43, 0x2E, KEYEVENTF_KEYUP)])
+ self.assertEqual(held, {})
+
+ def test_windows_caps_capture_reaches_ctrl_a_and_win_r_as_real_keys(self):
+ import capture_win
+ from sender import PHYSICAL
+ from core import keytable
+
+ for caps in (False, True):
+ for modifier_vk, vk, scan in ((0xA2, 0x41, 0x1E), (0x5B, 0x52, 0x13)):
+ with self.subTest(caps=caps, modifier=modifier_vk):
+ state = capture_win.KeyboardState()
+ state.caps_lock = caps
+
+ def translate(key, code, keyboard):
+ return chr(key) if keyboard[capture_win.VK_CAPITAL] else chr(key).lower()
+
+ captured = capture_win.VK_TO_NAME[modifier_vk]
+ modifier = keytable.wire_name(PHYSICAL.get(captured, captured),
+ "windows", "windows", "semantic")
+ name = capture_win.key_name(vk, scan, state, translate)
+ self.assertEqual(name, chr(vk) if caps else chr(vk).lower())
+ held = {}
+ lookup = lambda ch: vk | (0x100 if ch.isupper() else 0)
+ self.assertEqual(plan_key_inputs(name, True, {modifier}, held, lookup, lambda key: scan),
+ [(vk, scan, 0)])
+ self.assertEqual(plan_key_inputs(name, False, set(), held, lookup, lambda key: scan),
+ [(vk, scan, KEYEVENTF_KEYUP)])
class PlanKeyInputsBareCharacterTests(unittest.TestCase):