Skip to content

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

Beamer 1.5.18

Toby Kalkman6bd653d23820
diff --git a/VERSION b/VERSION
index 26c185e..83d4cf8 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.5.17
+1.5.18
diff --git a/flatpak/uk.co.kalkman.beamer.metainfo.xml b/flatpak/uk.co.kalkman.beamer.metainfo.xml
index 9883908..0ae0be3 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.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>
<release version="1.5.17" date="2026-10-28">
<description><p>Keypad keys now reach the other machine as keypad keys, not as the number row, so apps with keypad shortcuts such as Blender can tell them apart. Both machines need 1.5.17 for this. When a Mac's keyboard controls another machine, an accent from a dead key, such as ´ then e for é, no longer drops when you pause between the two keys. On a Mac, Beamer no longer uses more and more memory while you move the mouse or type.</p></description>
</release>
diff --git a/win_app/cursor_overlay.py b/win_app/cursor_overlay.py
new file mode 100644
index 0000000..6843b96
--- /dev/null
+++ b/win_app/cursor_overlay.py
@@ -0,0 +1,164 @@
+"""A system arrow for a remotely driven Windows desktop with no mouse cursor."""
+
+import ctypes
+from ctypes import wintypes
+import logging
+import sys
+
+from PySide6.QtCore import QTimer, Qt
+from PySide6.QtGui import QImage, QPainter
+from PySide6.QtWidgets import QWidget
+
+import desktop_win
+
+
+LOGGER = logging.getLogger(__name__)
+CURSOR_SHOWING = 1
+CURSOR_SUPPRESSED = 2
+SM_MOUSEPRESENT = 19
+
+
+def needs_overlay(driven, moved, flags, mouse_present):
+ # An attached mouse's hidden cursor can be deliberate (games and video players).
+ return bool(driven and moved and flags is not None and not mouse_present
+ and (not flags & CURSOR_SHOWING or flags & CURSOR_SUPPRESSED))
+
+
+class CURSORINFO(ctypes.Structure):
+ _fields_ = [("cbSize", wintypes.DWORD), ("flags", wintypes.DWORD),
+ ("hCursor", wintypes.HANDLE), ("ptScreenPos", wintypes.POINT)]
+
+
+class ICONINFO(ctypes.Structure):
+ _fields_ = [("fIcon", wintypes.BOOL), ("xHotspot", wintypes.DWORD),
+ ("yHotspot", wintypes.DWORD), ("hbmMask", wintypes.HBITMAP),
+ ("hbmColor", wintypes.HBITMAP)]
+
+
+user32 = ctypes.WinDLL("user32", use_last_error=True) if sys.platform == "win32" else None
+gdi32 = ctypes.WinDLL("gdi32", use_last_error=True) if sys.platform == "win32" else None
+if user32 is not None:
+ user32.GetCursorInfo.argtypes = [ctypes.POINTER(CURSORINFO)]
+ user32.GetCursorInfo.restype = wintypes.BOOL
+ user32.LoadCursorW.argtypes = [wintypes.HINSTANCE, ctypes.c_void_p]
+ user32.LoadCursorW.restype = wintypes.HANDLE
+ user32.GetIconInfo.argtypes = [wintypes.HANDLE, ctypes.POINTER(ICONINFO)]
+ user32.GetIconInfo.restype = wintypes.BOOL
+ user32.CreateIconIndirect.argtypes = [ctypes.POINTER(ICONINFO)]
+ user32.CreateIconIndirect.restype = wintypes.HANDLE
+ user32.DestroyIcon.argtypes = [wintypes.HANDLE]
+ user32.DestroyIcon.restype = wintypes.BOOL
+ user32.SetWindowPos.argtypes = [wintypes.HWND, wintypes.HWND, ctypes.c_int, ctypes.c_int,
+ ctypes.c_int, ctypes.c_int, wintypes.UINT]
+ user32.SetWindowPos.restype = wintypes.BOOL
+ gdi32.DeleteObject.argtypes = [wintypes.HANDLE]
+ gdi32.DeleteObject.restype = wintypes.BOOL
+
+
+class CursorOverlay(QWidget):
+ def __init__(self, moved, receiving, parent=None):
+ super().__init__(parent, Qt.Tool | Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint
+ | Qt.WindowTransparentForInput | Qt.WindowDoesNotAcceptFocus)
+ self.setAttribute(Qt.WA_TranslucentBackground)
+ self.setAttribute(Qt.WA_ShowWithoutActivating)
+ self.setFocusPolicy(Qt.NoFocus)
+ self._remote_move = moved
+ self._receiving = receiving
+ self._driven = False
+ self._moved = False
+ self._image = QImage()
+ self._hotspot = (0, 0)
+ self._failed = False
+ self._timer = QTimer(self)
+ self._timer.setInterval(16)
+ self._timer.timeout.connect(self._tick)
+
+ def set_active(self, driven):
+ self._driven = driven
+ if driven:
+ self._timer.start()
+ else:
+ self._timer.stop()
+ self._remote_move.clear()
+ self._moved = False
+ self.hide()
+
+ def _state(self):
+ info = CURSORINFO(cbSize=ctypes.sizeof(CURSORINFO))
+ if not user32.GetCursorInfo(ctypes.byref(info)):
+ raise ctypes.WinError(ctypes.get_last_error())
+ return info.flags, bool(user32.GetSystemMetrics(SM_MOUSEPRESENT)), info.ptScreenPos
+
+ def _tick(self):
+ if not self._driven or not self._receiving():
+ self._remote_move.clear()
+ self._moved = False
+ self.hide()
+ return
+ self._moved = self._moved or self._remote_move.is_set()
+ if not self._moved:
+ self.hide()
+ return
+ try:
+ flags, mouse_present, point = self._state()
+ if not needs_overlay(self._driven, self._moved, flags, mouse_present):
+ self.hide()
+ return
+ if not desktop_win._on_default_desktop():
+ self.hide()
+ return
+ self._load_arrow()
+ x, y = point.x - self._hotspot[0], point.y - self._hotspot[1]
+ if not self.isVisible():
+ self.move(x, y)
+ self.show()
+ hwnd = int(self.winId())
+ desktop_win.set_click_through(hwnd, True)
+ # Win32 cursor coordinates and window placement must share physical pixels at any DPI.
+ if not user32.SetWindowPos(hwnd, wintypes.HWND(-1), x, y, self._image.width(),
+ self._image.height(), 0x0010): # SWP_NOACTIVATE
+ raise ctypes.WinError(ctypes.get_last_error())
+ self._failed = False
+ except Exception:
+ self.hide()
+ if not self._failed:
+ LOGGER.exception("Could not draw the remote pointer")
+ self._failed = True
+
+ def _load_arrow(self):
+ arrow = user32.LoadCursorW(None, 32512) # IDC_ARROW is the user's current system arrow.
+ if not arrow:
+ raise ctypes.WinError(ctypes.get_last_error())
+ info = ICONINFO()
+ if not user32.GetIconInfo(arrow, ctypes.byref(info)):
+ raise ctypes.WinError(ctypes.get_last_error())
+ try:
+ # Qt's HICON conversion rejects monochrome HCURSORs; use the same bitmaps as an icon.
+ info.fIcon = True
+ icon = user32.CreateIconIndirect(ctypes.byref(info))
+ if not icon:
+ raise ctypes.WinError(ctypes.get_last_error())
+ try:
+ image = QImage.fromHICON(icon)
+ finally:
+ user32.DestroyIcon(icon)
+ if image.isNull():
+ raise OSError("Windows returned an empty system arrow")
+ ratio = self.devicePixelRatioF()
+ image.setDevicePixelRatio(ratio)
+ self._image = image
+ self._hotspot = (info.xHotspot, info.yHotspot)
+ self.resize(round(image.width() / ratio), round(image.height() / ratio))
+ self.update()
+ finally:
+ for bitmap in (info.hbmMask, info.hbmColor):
+ if bitmap:
+ gdi32.DeleteObject(bitmap)
+
+ def paintEvent(self, event):
+ painter = QPainter(self)
+ painter.drawImage(0, 0, self._image)
+
+ def closeEvent(self, event):
+ self.set_active(False)
+ super().closeEvent(event)
diff --git a/win_app/input_injector.py b/win_app/input_injector.py
index d37d064..6f44aad 100644
--- a/win_app/input_injector.py
+++ b/win_app/input_injector.py
@@ -17,6 +17,7 @@ from firewall_win import is_elevated
LOGGER = logging.getLogger(__name__)
+cursor_moved = threading.Event()
on_problem = None
_problem_at = float("-inf")
_problem_logged = None
@@ -511,6 +512,8 @@ def _mouse_input(dx: int, dy: int, data: int, flags: int) -> INPUT:
def inject_mouse_move(dx: int, dy: int) -> None:
_send_input(_mouse_input(dx, dy, 0, MOUSEEVENTF_MOVE))
+ if dx or dy:
+ cursor_moved.set()
watch_foreground()
diff --git a/win_app/kvm_bridge_win.py b/win_app/kvm_bridge_win.py
index 90b4921..db6fb64 100644
--- a/win_app/kvm_bridge_win.py
+++ b/win_app/kvm_bridge_win.py
@@ -581,6 +581,7 @@ class WindowsApplication(QWidget):
self._veil = None
self._veil_hwnd = 0
self._driven = False
+ self._cursor_overlay = None
self._idle_pointer = self._make_idle_pointer()
self.bridge.peers_changed.connect(self._on_peers_changed)
self.bridge.arrangement.connect(self._on_arrangement)
@@ -5344,6 +5345,16 @@ class WindowsApplication(QWidget):
self._idle_pointer.cancel()
elif was_driven and not self._closing and self._hiding_pointer():
self._idle_pointer.driver_left()
+ if sys.platform == "win32":
+ overlay = getattr(self, "_cursor_overlay", None)
+ if overlay is None and self._driven and not self._input_controller_blocked:
+ from cursor_overlay import CursorOverlay
+ overlay = self._cursor_overlay = CursorOverlay(
+ platform_parts.injector.cursor_moved,
+ lambda: getattr(self.server, "pointer_owner", self.server.owner) is not None,
+ )
+ if overlay is not None:
+ overlay.set_active(self._driven)
self._refresh_tray_state()
def _on_peers_changed(self) -> None:
@@ -5525,6 +5536,9 @@ class WindowsApplication(QWidget):
stop_injector = getattr(platform_parts.injector, "stop", None)
if stop_injector is not None:
stop_injector()
+ overlay = getattr(self, "_cursor_overlay", None)
+ if overlay is not None:
+ overlay.close()
self._hide_crossing()
if self._idle_pointer is not None:
self._idle_pointer.cancel()
diff --git a/win_app/tests/test_cursor_overlay.py b/win_app/tests/test_cursor_overlay.py
new file mode 100644
index 0000000..f2d43d6
--- /dev/null
+++ b/win_app/tests/test_cursor_overlay.py
@@ -0,0 +1,129 @@
+import unittest
+import threading
+from ctypes import wintypes
+from unittest import mock
+
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QImage
+
+import cursor_overlay
+import input_injector
+
+from cursor_overlay import needs_overlay
+
+
+class CursorDecisionTests(unittest.TestCase):
+ def test_remote_move_on_mouseless_target_has_a_pointer(self):
+ self.assertTrue(needs_overlay(True, True, 0, False))
+
+ def test_visible_native_pointer_wins(self):
+ self.assertFalse(needs_overlay(True, True, 1, False))
+
+ def test_suppressed_native_pointer_is_not_drawn(self):
+ self.assertTrue(needs_overlay(True, True, 2, False))
+ self.assertTrue(needs_overlay(True, True, 3, False))
+
+ def test_driver_leaves(self):
+ self.assertFalse(needs_overlay(False, True, 0, False))
+
+ def test_no_pointer_until_remote_movement(self):
+ self.assertFalse(needs_overlay(True, False, 0, False))
+
+ def test_mouse_plugged_in_mid_session(self):
+ self.assertTrue(needs_overlay(True, True, 0, False))
+ self.assertFalse(needs_overlay(True, True, 0, True))
+
+ def test_apps_can_intentionally_hide_an_attached_mouse(self):
+ self.assertFalse(needs_overlay(True, True, 0, True))
+
+ def test_unknown_cursor_state_fails_closed(self):
+ self.assertFalse(needs_overlay(True, True, None, False))
+
+
+class CursorLifecycleTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def setUp(self):
+ self.moved = threading.Event()
+ self.overlay = cursor_overlay.CursorOverlay(self.moved, lambda: True)
+ self.addCleanup(self.overlay.close)
+
+ def test_idle_ownership_does_not_poll_or_create_a_native_window(self):
+ self.overlay.set_active(True)
+ with mock.patch.object(self.overlay, "_state") as state:
+ self.overlay._tick()
+ state.assert_not_called()
+ self.assertFalse(self.overlay.isVisible())
+
+ def test_driver_leaves_stops_polling_and_clears_old_movement(self):
+ self.overlay.set_active(True)
+ self.moved.set()
+ self.overlay.set_active(False)
+ self.assertFalse(self.overlay._timer.isActive())
+ self.assertFalse(self.moved.is_set())
+ self.assertFalse(self.overlay.isVisible())
+ self.overlay.set_active(True)
+ with mock.patch.object(self.overlay, "_state") as state:
+ self.overlay._tick()
+ state.assert_not_called()
+
+ def test_failed_cursor_query_hides_the_overlay(self):
+ self.overlay.set_active(True)
+ self.moved.set()
+ with mock.patch.object(self.overlay, "_state", side_effect=OSError("unavailable")):
+ with self.assertLogs(cursor_overlay.LOGGER, "ERROR"):
+ self.overlay._tick()
+ self.assertFalse(self.overlay.isVisible())
+
+ def test_successful_shared_injection_marks_movement(self):
+ input_injector.cursor_moved.clear()
+ self.addCleanup(input_injector.cursor_moved.clear)
+ with mock.patch.object(input_injector, "user32"), \
+ mock.patch.object(input_injector, "_send_input"), \
+ mock.patch.object(input_injector, "watch_foreground"):
+ input_injector.inject_mouse_move(3, 4)
+ self.assertTrue(input_injector.cursor_moved.is_set())
+
+ def test_failed_injection_does_not_start_drawing(self):
+ input_injector.cursor_moved.clear()
+ self.addCleanup(input_injector.cursor_moved.clear)
+ with mock.patch.object(input_injector, "user32"), \
+ mock.patch.object(input_injector, "_send_input", side_effect=OSError("blocked")):
+ with self.assertRaises(OSError):
+ input_injector.inject_mouse_move(3, 4)
+ self.assertFalse(input_injector.cursor_moved.is_set())
+
+ def test_local_drag_wakeup_cannot_leave_stale_remote_movement(self):
+ input_injector.cursor_moved.clear()
+ self.addCleanup(input_injector.cursor_moved.clear)
+ with mock.patch.object(input_injector, "user32"), \
+ mock.patch.object(input_injector, "_send_input"), \
+ mock.patch.object(input_injector, "watch_foreground"):
+ input_injector.inject_mouse_move(0, 0)
+ self.assertFalse(input_injector.cursor_moved.is_set())
+
+ def test_arrow_contents_refresh_when_windows_reuses_its_handle(self):
+ first = QImage(16, 16, QImage.Format_ARGB32)
+ first.fill(0xff010203)
+ second = QImage(16, 16, QImage.Format_ARGB32)
+ second.fill(0xff040506)
+ with mock.patch.object(cursor_overlay, "user32") as api, \
+ mock.patch.object(QImage, "fromHICON", side_effect=[first, second]):
+ api.LoadCursorW.return_value = 1
+ api.GetIconInfo.return_value = True
+ api.CreateIconIndirect.return_value = 2
+ self.overlay._load_arrow()
+ self.assertEqual(self.overlay._image.pixel(0, 0), 0xff010203)
+ self.overlay._load_arrow()
+ self.assertEqual(self.overlay._image.pixel(0, 0), 0xff040506)
+
+ def test_keyboard_owner_cannot_keep_a_departed_pointers_overlay_alive(self):
+ self.overlay._receiving = lambda: False
+ self.overlay.set_active(True)
+ self.moved.set()
+ with mock.patch.object(self.overlay, "_state", return_value=(1, False, wintypes.POINT())) as state:
+ self.overlay._tick()
+ state.assert_not_called()
+ self.assertFalse(self.moved.is_set())
diff --git a/win_app/tests/test_cursor_overlay_native.py b/win_app/tests/test_cursor_overlay_native.py
new file mode 100644
index 0000000..3cf570b
--- /dev/null
+++ b/win_app/tests/test_cursor_overlay_native.py
@@ -0,0 +1,124 @@
+"""Opt-in Win32 proof; its window stays outside every monitor and never injects input."""
+
+import ctypes
+from ctypes import wintypes
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+import unittest
+from unittest import mock
+
+from PySide6.QtCore import QPoint
+from PySide6.QtGui import QColor, QImage, QPainter
+from PySide6.QtWidgets import QApplication
+
+import cursor_overlay
+
+
[email protected](sys.platform == "win32" and os.environ.get("BEAMER_CURSOR_NATIVE_PROOF") == "1",
+ "opt-in native offscreen proof")
+class NativeCursorTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def test_native_window_recovers_and_releases_without_taking_input(self):
+ api = cursor_overlay.user32
+ api.GetForegroundWindow.restype = wintypes.HWND
+ api.GetWindowLongPtrW.argtypes = [wintypes.HWND, ctypes.c_int]
+ api.GetWindowLongPtrW.restype = ctypes.c_ssize_t
+ api.GetWindowRect.argtypes = [wintypes.HWND, ctypes.POINTER(wintypes.RECT)]
+ foreground = api.GetForegroundWindow()
+ moved = threading.Event()
+ overlay = cursor_overlay.CursorOverlay(moved, lambda: True)
+ self.addCleanup(overlay.close)
+ live_flags, live_mouse, live_point = overlay._state()
+ # Running Beamer can temporarily blank shared cursors. Read its configured arrow without restoring them.
+ import winreg
+ with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Control Panel\Cursors") as key:
+ arrow_file = os.path.expandvars(winreg.QueryValueEx(key, "Arrow")[0])
+ if not arrow_file:
+ self.skipTest("native proof needs an explicit system arrow file")
+ api.LoadCursorFromFileW.argtypes = [wintypes.LPCWSTR]
+ api.LoadCursorFromFileW.restype = wintypes.HANDLE
+ api.DestroyCursor.argtypes = [wintypes.HANDLE]
+ arrow = api.LoadCursorFromFileW(arrow_file)
+ self.assertTrue(arrow)
+ self.addCleanup(api.DestroyCursor, arrow)
+ arrow_source = mock.patch.object(api, "LoadCursorW", return_value=arrow)
+ arrow_source.start()
+ self.addCleanup(arrow_source.stop)
+ x = api.GetSystemMetrics(76) + api.GetSystemMetrics(78) + 1000
+ y = api.GetSystemMetrics(77) + api.GetSystemMetrics(79) + 1000
+ point = wintypes.POINT(x, y)
+ overlay.set_active(True)
+ moved.set()
+ with mock.patch.object(overlay, "_state", return_value=(0, False, point)):
+ overlay._tick()
+ self.app.processEvents()
+ overlay._tick()
+ self.assertFalse(overlay._failed)
+ self.assertTrue(overlay.isVisible())
+ hwnd = int(overlay.winId())
+ style = api.GetWindowLongPtrW(hwnd, -20)
+ required = 0x20 | 0x80000 | 0x8 | 0x08000000
+ self.assertEqual(style & required, required)
+ self.assertEqual(api.GetForegroundWindow(), foreground)
+ rect = wintypes.RECT()
+ self.assertTrue(api.GetWindowRect(hwnd, ctypes.byref(rect)))
+ self.assertEqual((rect.left, rect.top), (x - overlay._hotspot[0], y - overlay._hotspot[1]))
+ self.assertEqual((rect.right - rect.left, rect.bottom - rect.top),
+ (overlay._image.width(), overlay._image.height()))
+ self.assertGreater(overlay._image.width(), 0)
+ point.x += 100
+ point.y += 70
+ with mock.patch.object(overlay, "_state", return_value=(0, False, point)):
+ overlay._tick()
+ self.assertTrue(api.GetWindowRect(hwnd, ctypes.byref(rect)))
+ self.assertEqual((rect.left, rect.top),
+ (point.x - overlay._hotspot[0], point.y - overlay._hotspot[1]))
+ shot = overlay.grab().toImage()
+ self.assertTrue(any(shot.pixelColor(a, b).alpha() > 0
+ for a in range(shot.width()) for b in range(shot.height())))
+ folder = os.environ.get("BEAMER_CURSOR_PROOF_DIR")
+ if folder:
+ target = Path(folder)
+ target.mkdir(parents=True, exist_ok=True)
+ self.assertTrue(shot.save(str(target / "native-arrow.png")))
+ canvas = QImage(320, 160, QImage.Format_ARGB32)
+ canvas.fill(QColor("#f4f4f4"))
+ painter = QPainter(canvas)
+ painter.fillRect(160, 0, 160, 160, QColor("#202020"))
+ painter.drawImage(QPoint(64, 48), shot)
+ painter.drawImage(QPoint(224, 48), shot)
+ painter.end()
+ self.assertTrue(canvas.save(str(target / "native-arrow-backgrounds.png")))
+ (target / "native-proof.json").write_text(json.dumps({
+ "live_cursor_flags": live_flags, "live_mouse_present": live_mouse,
+ "live_position": [live_point.x, live_point.y],
+ "forced_flags": 0, "forced_mouse_present": False,
+ "arrow_source": "configured system arrow file; shared cursor left untouched",
+ "extended_style": hex(style), "required_style": hex(required),
+ "window_rect": [rect.left, rect.top, rect.right, rect.bottom],
+ "hotspot": overlay._hotspot, "image_size": [shot.width(), shot.height()],
+ "device_pixel_ratio": overlay.devicePixelRatioF(),
+ "foreground_unchanged": api.GetForegroundWindow() == foreground,
+ }, indent=2), encoding="utf-8")
+ with mock.patch.object(overlay, "_state", return_value=(1, False, point)):
+ overlay._tick()
+ self.assertFalse(overlay.isVisible())
+ with mock.patch.object(overlay, "_state", return_value=(0, False, point)):
+ overlay._tick()
+ self.assertTrue(overlay.isVisible())
+ with mock.patch.object(overlay, "_state", return_value=(0, True, point)):
+ overlay._tick()
+ self.assertFalse(overlay.isVisible())
+ with mock.patch.object(overlay, "_state", return_value=(0, False, point)), \
+ mock.patch.object(cursor_overlay.desktop_win, "_on_default_desktop", return_value=False):
+ overlay._tick()
+ self.assertFalse(overlay.isVisible())
+ overlay.set_active(False)
+ self.assertFalse(overlay.isVisible())
+ self.assertFalse(overlay._timer.isActive())
diff --git a/win_app/tests/test_cursor_overlay_ownership.py b/win_app/tests/test_cursor_overlay_ownership.py
new file mode 100644
index 0000000..d85e0a1
--- /dev/null
+++ b/win_app/tests/test_cursor_overlay_ownership.py
@@ -0,0 +1,69 @@
+import sys
+from types import SimpleNamespace
+import unittest
+from unittest import mock
+
+from PySide6.QtWidgets import QApplication
+
+import kvm_bridge_win
+
+
[email protected](sys.platform == "win32", "Windows cursor fallback")
+class OwnershipTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.app = QApplication.instance() or QApplication([])
+
+ def window(self, blocked=False):
+ return SimpleNamespace(
+ sender=mock.Mock(), _driven=False, _idle_pointer=None, _closing=False,
+ _input_controller_blocked=blocked, _cursor_overlay=None,
+ server=SimpleNamespace(owner=b"peer", pointer_owner=b"peer"),
+ _refresh_tray_state=mock.Mock(), _refresh_tray_machines=mock.Mock(),
+ _refresh_redirect_controls=mock.Mock(),
+ )
+
+ def test_shared_owner_signal_starts_and_releases_fallback(self):
+ window = self.window()
+ moved = kvm_bridge_win.platform_parts.injector.cursor_moved
+ moved.clear()
+ self.addCleanup(moved.clear)
+ kvm_bridge_win.WindowsApplication._on_owner(window, "peer-one")
+ overlay = window._cursor_overlay
+ self.addCleanup(overlay.close)
+ self.assertTrue(overlay._timer.isActive())
+ moved.set()
+ kvm_bridge_win.WindowsApplication._on_owner(window, "peer-two")
+ self.assertIs(window._cursor_overlay, overlay)
+ kvm_bridge_win.WindowsApplication._on_owner(window, "")
+ self.assertFalse(overlay._timer.isActive())
+ self.assertFalse(moved.is_set())
+
+ def test_non_controller_process_does_not_create_a_window(self):
+ window = self.window(blocked=True)
+ kvm_bridge_win.WindowsApplication._on_owner(window, "peer")
+ self.assertIsNone(window._cursor_overlay)
+
+ def test_local_ownership_does_not_create_a_window(self):
+ window = self.window()
+ kvm_bridge_win.WindowsApplication._on_owner(window, "")
+ self.assertIsNone(window._cursor_overlay)
+
+ def test_independent_keyboard_owner_does_not_count_as_pointer_control(self):
+ window = self.window()
+ kvm_bridge_win.WindowsApplication._on_owner(window, "peer")
+ overlay = window._cursor_overlay
+ self.addCleanup(overlay.close)
+ self.assertTrue(overlay._receiving())
+ window.server.pointer_owner = None
+ self.assertFalse(overlay._receiving())
+
+ def test_legacy_receiver_uses_its_single_owner(self):
+ window = self.window()
+ del window.server.pointer_owner
+ kvm_bridge_win.WindowsApplication._on_owner(window, "peer")
+ overlay = window._cursor_overlay
+ self.addCleanup(overlay.close)
+ self.assertTrue(overlay._receiving())
+ window.server.owner = None
+ self.assertFalse(overlay._receiving())