remotedesktop 1.6.0__tar.gz → 1.8.0__tar.gz

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/CLAUDE.md

@@ -76,12 +76,13 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Auto-reconnect** (`app.py`): a session that *was connected* and drops retries `client.connect_to` with exponential backoff (base `reconnect_base_seconds=2.0` kwarg — tests inject ~0.05 — doubling to a 30 s cap), driven by a per-session single-shot QTimer. `ShareClient.connectionFailed` exists because **Qt emits `disconnected` only for sockets that reached ConnectedState** — refused/unreachable attempts fire `errorOccurred` with the socket back in UnconnectedState. The active-timer guard dedupes the errorOccurred+disconnected double-fire. Denial cancels until a manual activation; tab close/forget/quit cancel; retries bypass `_connect_session` on purpose (no perf reset, no tab steal, no inventory attempt spam). **Open session tabs persist** (`open_sessions` JSON in Settings, written on connect/rename/close) and are restored + reconnected at startup with `auto_reconnect` pre-armed, so a not-yet-available server is retried on the backoff loop; deliberately closed tabs are not restored. While no session exists, a non-closable "Server" placeholder tab (instructions) sits at index 0 and swaps with the first session's tab.
 - **Menus & shortcuts contract** (`app.py` `_build_menus`, `viewer.py`): File/View/Help menu bar; shortcuts Ctrl+W (close session tab), Ctrl+Q (quit), F5 (rescan), F11 (fullscreen). While a viewer shows a frame it **accepts `ShortcutOverride`** so every key forwards to the remote machine — **F11 is the single reserved local key**. Shortcut actions are also `addAction`-ed on the window so they fire with the menu bar hidden (fullscreen). Keep every menu/action as an attribute — PySide6 gives Python ownership of `addMenu`/`addAction` (and `QAction.menu()`) wrappers, and a GC'd local deletes the C++ object. Fullscreen hides menu/status bars, dock, and tab bar and restores them (including pre-fullscreen dock visibility) on exit; `closeEvent` exits fullscreen before persisting layout. Window geometry AND dock layout persist (`window_state.save_state`/`restore_state`, key `main_window_state`; the dock needs its objectName).
 - **Privacy toggles**: Preferences' "Sync clipboard" checkbox (`clipboard_sync_enabled`, default on) drives `ClipboardSync.enabled` — while off, local copies aren't sent and peer payloads aren't applied. View-only sharing is the "view" mode of the Screen sharing radios (`ShareServer.set_input_allowed` — a server-side drop, no wire change, that releases held input when switched off). Quitting with ≥1 viewer connected asks for confirmation (declining resets `_quitting`); restart shuts sharing down first so it never double-prompts.
+- **Reduce visual effects while sharing** (`visual_effects.py`): animations/fades are a burst of changed frames for the lossless pipeline, so while the preference is on (default on, `reduce_effects_enabled`, `load_reduce_effects_enabled`) **and ≥1 viewer is connected**, `MainWindow` applies `VisualEffectsReducer` and restores it when the last viewer leaves (driven by `SharingTab.viewerCountChanged`; explicit safety-net restore in `closeEvent`). The reduced set: SPI_SETUIEFFECTS off, drop shadows off, client-area + min/max animations off, submenu delay lowered to 50 ms (never raised). All via `SystemParametersInfo` **without** SPIF_UPDATEINIFILE — session-scoped, never persisted, self-heals at logoff; knobs already at the reduced value are left untouched so the user's own choices are never "restored" over. The backend (`SpiBackend`) is injectable — **tests must always inject `FakeSpiBackend`** (the preference defaults on, so a real reducer in a test would change the host's actual Windows settings; `make_window` in `tests/test_main_window.py` injects it for every window test, and real-backend tests may only read).
 - **Theme preference** (`preferences.py`): a three-radio group in Preferences — follow the Windows light/dark setting (default) / Light / Dark — persisted as `THEME_KEY` (`"system"`/`"light"`/`"dark"`, `load_theme` falls back to system on junk). `apply_theme` drives `QStyleHints.setColorScheme` (`unsetColorScheme` for system, so OS-side switches keep applying); the radios apply live and `MainWindow.__init__` re-applies the persisted choice before building widgets. Tests that set a non-system theme must restore with `apply_theme(THEME_SYSTEM)` — the color scheme is process-global QApplication state.
 - **Two `PerformanceMonitor`s, never one**: `MainWindow.client_performance` (viewing sessions) and `server_performance` (the SharingTab's viewers). `ShareServer.close()` resets its monitor, so sharing a monitor across roles would wipe the other role's graphs. The Performance tab has "Client (viewer)"/"Server (sharing)" sub-tabs (`MainWindow.performance_pages`) — but only for roles that can produce data: the client sub-tab exists only with the viewer role, the server one only while actually serving (`_update_performance_tabs`, driven from the viewer toggle and `sharingChanged`; both off shows an enable-a-role hint). `PreferencesTab` takes the list of monitors and applies the history-window setting to all.
 - **Autodiscovery** (`src/remotedesktop/discovery.py`) is a stdlib-only UDP probe/response protocol, deliberately not mDNS: the client broadcasts a JSON probe to `DISCOVERY_PORT` (48653) and servers reply with `{name, port}`; datagrams with the wrong magic/version/type are dropped. **Scan robustness**: probes are re-sent every `_PROBE_INTERVAL` (0.3 s) for the whole scan window (a lost broadcast only delays discovery), ICMP port-unreachable resets never abort the scan (Windows `SIO_UDP_CONNRESET` ioctl + `ConnectionResetError` → continue), and the panel passes `client._broadcast_hosts()` — 255.255.255.255 plus every up non-loopback interface's directed broadcast, because Windows routes the limited broadcast out only one interface (VPN/virtual adapters made scans come up empty). A sharing instance runs a `DiscoveryResponder` thread while sharing is enabled; the `DiscoveryPanel` (dock in `MainWindow`) calls the blocking `discover_servers()` on a worker thread and delivers results to the GUI via a queued signal. With `auto_scan=True` (the app; tests default to False and never broadcast) it scans **once at startup only** — further scans happen only on manual Refresh/F5 (deliberately no periodic background scanning; the user asked for this), guarded against overlapping scans and preserving the selection across repopulation; it also has a Connect button, a right-click Connect menu, and an empty-state hint. The "(this computer)" entry is not connectable (Connect disabled, activation swallowed, plus a `MainWindow._on_server_activated` guard). `DEFAULT_CONNECT_PORT` is 48654. An instance that shares and scans discovers itself — `DiscoveryPanel`'s `is_self=` callable labels that entry "(this computer)" (never hidden).
 - Discovery tests run over loopback with ephemeral ports (`bind_host`/`discovery_port`/`broadcast_hosts` parameters exist for this), so they never touch the real LAN or fixed ports.
 - **Screen sharing** (`sharing.py` + `protocol.py` + `frames.py`) runs entirely on the Qt event loop — no threads or locks. `MessageStream` frames messages over a QTcpSocket (4-byte length + kind byte; JSON control messages, full frames, or inter-frame deltas; malformed input aborts the socket). `ShareServer` owns one QTimer that grabs the primary screen at full resolution via `_capture()` (a seam tests override to drive deterministic frame content) and fans out to all clients, skipping clients whose send buffer is backlogged; the timer only runs while clients are connected. Capture is DXGI desktop duplication (`dxgi.py`, hand-rolled ctypes COM — ~10 ms per changed 4K frame, ~0 when idle, and "unchanged" is signalled by returning the same QImage object so the diff is skipped) with automatic fallback to `QScreen.grabWindow` (~96 ms) whenever duplication is unavailable or lost (secure desktop, RDP, display-mode change, CI); unit tests fake the duplication (`FakeDuplication` in `tests/test_dxgi.py`) and the real-hardware test skips where DXGI is unavailable. **Frame transfer is lossless and inter-frame compressed** (`frames.py`): consecutive captures are diffed in 64-row bands (memoryview compares), and only changed bands ship as PNG in a delta payload the client patches onto its previous frame; an unchanged screen sends nothing. Full PNG keyframes go to clients that just joined, just recovered from a send backlog, or requested one (a `{"type": "keyframe"}` message — sent when a delta fails to apply, so desync self-heals). The capability is negotiated via `"delta": true` in the client hello; clients without it (0.5.0) get full JPEG frames every tick because they force-decode frames as JPEG — never send them PNG. Each variant (legacy JPEG / keyframe PNG / delta) is encoded at most once per tick and shared across clients. `ShareClient` decodes/patches to QImage for the viewer, which displays it scaled with a cached `SmoothTransformation` copy (full resolution is always delivered; scaling happens client-side only).
-- **All persistence is one SQLite database** (`db.py`): `db.connect(path)` opens the DB and ensures every table (`settings`, `paired_clients`, `known_servers`, and the inventory tables). The file lives at `config.default_db_path()` — `platformdirs.user_data_dir("remotedesktop")` (`%LOCALAPPDATA%\remotedesktop\remotedesktop.db` on Windows). **Use `platformdirs` for any new data location; don't hardcode `%APPDATA%`.** Every store (`Settings`, `PairedClients`, `KnownServers`, `ConnectionInventory`) takes a `sqlite3.Connection`; the app opens one connection and shares it. `MainWindow` takes a `connection=` keyword so tests inject a temp-file DB and never touch the real one (see `tests/test_main_window.py` / `test_sharing_tab.py`). Tests pass `db.connect(tmp_path/"x.db")` (or omit for in-memory), and use **separate DB files per simulated machine**.
+- **All persistence is one SQLite database** (`db.py`): `db.connect(path)` opens the DB and ensures every table (`settings`, `paired_clients`, `known_servers`, and the inventory tables). The file lives at `config.default_db_path()` — `platformdirs.user_data_dir("remotedesktop")` (`%LOCALAPPDATA%\remotedesktop\remotedesktop.db` on Windows). **Use `platformdirs` for any new data location; don't hardcode `%APPDATA%`.** Every store (`Settings`, `PairedClients`, `KnownServers`, `ConnectionInventory`) takes a `sqlite3.Connection`; the app opens one connection and shares it. **Boolean settings go through `Settings.get_bool`/`set_bool`** (the `tobool` package's `to_bool_strict`; on-disk form stays the historical `"1"`/`"0"`, junk falls back to the caller's default) — don't hand-roll `!= "0"` comparisons. This applies to binary values stored as strings/ints; ctypes Win32 `BOOL`s keep plain `bool()` (TRUE is "any nonzero", which strict parsing correctly refuses). `MainWindow` takes a `connection=` keyword so tests inject a temp-file DB and never touch the real one (see `tests/test_main_window.py` / `test_sharing_tab.py`). Tests pass `db.connect(tmp_path/"x.db")` (or omit for in-memory), and use **separate DB files per simulated machine**.
 - **Trust model plumbing** (`config.py`): the client has a stable UUID identity (`load_client_identity`, in the `settings` table) and the server maps each approved client-id to a token (`PairedClients`). `ShareServer` takes an `approve_client(client_id, name) -> bool` callback; `SharingTab` implements it as a modal stay-on-top QMessageBox. Tests inject stores backed by a temp DB and explicit identities so they never touch real data or prompt.
 - **Status/debug logging is a feature**: `ShareServer`, `ShareClient`, `SharingTab`, and `DiscoveryPanel` emit human-readable `status`/`statusMessage` signals for every connection phase, shown in the window's timestamped "Connection log" pane. When adding connection behavior, emit a status message for each new phase or failure path — there's a test asserting the server's phase messages. Everything the pane shows is also written to a rotating debug log file (`logs.py`; `logs.init_logging("remotedesktop")` is called only by `app.main()`, under `platformdirs.user_log_dir("remotedesktop")` — `%LOCALAPPDATA%\remotedesktop\Logs\remotedesktop.log` on Windows; pre-1.0 `client.log`/`server.log` files just age out). Lower-level detail (socket state changes, protocol aborts, frame-drop/backlog, discovery datagram drops) goes straight to `logging.getLogger("remotedesktop.*")` at debug/warning level — silent failure paths should log there even when a status message would be too noisy. Library code and tests never call `init_logging`; without a handler those loggers are no-ops.
 - **Connection inventory** (`inventory.py`): the Connections tab has two grouped tables ("Client history" for the sharing role, "Server history" for the viewing role), each backed by its own `ConnectionInventory` — one `PeerRecord` per peer with attempts count, current state, first/last seen. The sharing side is driven by `ShareServer.peerEvent` (a structured `{key, event, name, address, detail}` signal emitted alongside the status strings at each phase — keep both in sync when adding phases), forwarded through `SharingTab.peerEvent`. The viewing side is driven by `MainWindow`'s own handlers (discovered servers from `DiscoveryPanel.serversFound`, plus attempt/connected/denied/disconnected). Server peers key by client-id; client peers key by `host:port`. **Persisted in SQLite** and reloaded on startup, so it survives restarts.
@@ -89,6 +90,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - Sharing tests drive real sockets on the GUI thread by pumping `qapp.processEvents()` until a condition holds (see `pump()` in `tests/test_sharing.py`). Use the `make_server`/`make_client` helpers there and the session-scoped `credentials` fixture (one generated cert reused across tests — generating per test is ~100ms each). Tests exercise the real pairing flow (auto-approve), so there is no "pre-approve" shortcut anymore.
 - **Input forwarding**: `ViewerWidget` captures mouse/keyboard events and emits `inputEvent` dicts with coordinates normalized 0..1 over the *displayed* frame rect (letterboxing is reversed via `_display_rect()`; events outside the frame are dropped). Keys carry the client's `nativeVirtualKey()` — since both ends are Windows, the server injects that VK directly with no key-translation table. The client sends these as `{"type": "input", ...}`; `ShareServer` only injects input from streams that completed the hello/approval handshake.
 - **Remote cursor shape** (`cursor_shape.py`): the captured frame never contains the mouse pointer (DXGI duplication and BitBlt both exclude it), so the client mirrors the server's cursor on its *local* cursor instead. `ShareServer` takes an opt-in `cursor_probe=` callable (the `clipboard=` pattern — only the GUI passes one, `SharingTab` wires `current_cursor_shape`: GetCursorInfo compared against the shared standard IDC_* handles; custom cursors → "arrow", not showing → "hidden"). The probe is polled each broadcast tick and `{"type": "cursor", "shape": ...}` is sent on change only, plus once to each just-admitted stream. `ShareClient.cursorShapeChanged` → `ViewerWidget.set_remote_cursor` maps names to Qt cursors (unknown names → arrow); `clear()` unsets the cursor. Peers without the feature never send / silently ignore the message.
+- **Lock-screen notice** (`session_lock.py`): the Windows lock screen / secure desktop (also UAC, Ctrl+Alt+Del) can be neither captured nor injected into by a user-mode process, so remote unlock is impossible by design (documented in the readme; the assumption is the server machine is physically reachable to sign in). `ShareServer` takes an opt-in `lock_probe=` callable (the `cursor_probe=` pattern — only the GUI wires `is_session_locked`, which reads OpenInputDesktop failure as "secure desktop has input"). Polled each broadcast tick; `{"type": "session_lock", "locked": bool}` is sent on change, plus to just-admitted streams while locked (unlocked is the assumed start state, so it's never sent on admission). While locked the server drops remote input with a once-per-lock-episode status line ("Ignoring remote input while the session is locked"). `ShareClient.sessionLockChanged` → `ViewerWidget.set_session_locked`: the viewer dims whatever it shows under `viewer.LOCKED_MESSAGE`; `clear()` resets it (so reconnects start unlocked). Peers without the feature never send / silently ignore the message. Sharing tests inject a fake `lock_probe` — the default None means plain tests never poll the host's real desktop.
 - **Modal-loop pump** (`modal_loop.py`): a Windows title-bar drag (or click-and-hold) puts the window's thread into a native modal move/size loop where Qt's dispatcher stops — for a sharing instance this deadlocked when a *remote* click grabbed the window's own title bar (the mouse-up sat unread on the socket). `MainWindow.nativeEvent` feeds `ModalLoopPump`, which runs a native `SetTimer` from `WM_NCLBUTTONDOWN` (a press-and-hold that never moves blocks in DefWindowProc's click tracking without ever sending `WM_ENTERSIZEMOVE`) until `WM_CAPTURECHANGED`/`WM_EXITSIZEMOVE`, whose callback pumps Qt events (user input excluded). The caption buttons (min/max/close) are the exception — their tracking loop dispatches only mouse messages, so no timer can pump inside it; the pump instead performs those via its `caption_action` callback on press and consumes the message (nativeEvent must return True when `handle_native_event` does), so DefWindowProc's button tracking never starts. Tests inject a fake `timers` backend — never let them create real Win32 timers.
 - **Log exchange**: either side can fetch the peer's debug log over the connection (`{"type": "log_request"}` → `{"type": "log", "text": ...}`, admitted streams only). `ShareServer`/`ShareClient` take a `log_provider=` callable (the app passes `logs.read_log_tail("remotedesktop")`, capped at `logs.TAIL_BYTES`); a missing provider/file answers with a placeholder rather than hanging the requester. The Connection log group on the Connections tab has both buttons — "Get server log" asks the server of the current session tab, "Get client log" asks the most recently admitted viewer; the reply opens a `logs.PeerLogDialog`.
 - **Injection is isolated behind `InputInjector`** (`input_injection.py`, Windows `SendInput` via ctypes; inert stub off-Windows). ShareServer takes an `injector=` param so tests pass a recording fake — **never let tests construct a real `InputInjector`, or they will move the host's actual mouse/keyboard.** Normalized 0..1 coords map directly to SendInput's 0..65535 absolute range over the primary monitor.

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 1.6.0
+Version: 1.8.0
 Summary: Remote desktop app for Windows computers on the same LAN, with autodiscovery. View other computers and optionally share this one — screen, keyboard, mouse, and clipboard, without RDP or Microsoft authentication.
 Project-URL: Homepage, https://github.com/jamesabel/remotedesktop
 Project-URL: Repository, https://github.com/jamesabel/remotedesktop
@@ -19,6 +19,7 @@ Requires-Dist: cryptography>=49.0.0
 Requires-Dist: platformdirs>=4.10.0
 Requires-Dist: pyside6>=6.11.1
 Requires-Dist: semver>=3.0
+Requires-Dist: tobool>=0.4.0
 Description-Content-Type: text/markdown
 
 # Remote Desktop
@@ -138,6 +139,28 @@ access can be revoked at any time from the *Connections* tab. There is
 no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## The Windows lock screen
+
+**A locked computer cannot be viewed or unlocked remotely.** The lock
+screen, the PIN/password prompt, and UAC elevation prompts run on a
+separate *secure desktop* that Windows deliberately walls off from
+ordinary applications: nothing running as the signed-in user may capture
+it or type into it, so no software can read or fill in a credential
+prompt. This app intentionally runs as the signed-in user — no admin
+rights, no system service — so it sits on the application side of that
+wall (remote-access products that can show the login screen install a
+privileged Windows service to cross it).
+
+What happens instead: when the shared computer locks, viewers stay
+connected and see a clear *"The remote computer is locked"* notice over
+the last frame, and any input they send is ignored until the computer is
+unlocked. The working assumption is that you (or someone nearby) can get
+to the shared computer to sign it in; once its desktop is unlocked,
+streaming and control resume on their own. If that round trip is a
+nuisance, keep the shared computer signed in while you work on it
+remotely — for example by lengthening its lock/sleep timeout in Windows
+settings.
+
 ## How it works
 
 All of this is pure Python — the GUI is PySide6 (Qt), and the two places

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     "platformdirs>=4.10.0",
     "pyside6>=6.11.1",
     "semver>=3.0",
+    "tobool>=0.4.0",
 ]
 
 [project.urls]

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/readme.md

@@ -115,6 +115,28 @@ access can be revoked at any time from the *Connections* tab. There is
 no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## The Windows lock screen
+
+**A locked computer cannot be viewed or unlocked remotely.** The lock
+screen, the PIN/password prompt, and UAC elevation prompts run on a
+separate *secure desktop* that Windows deliberately walls off from
+ordinary applications: nothing running as the signed-in user may capture
+it or type into it, so no software can read or fill in a credential
+prompt. This app intentionally runs as the signed-in user — no admin
+rights, no system service — so it sits on the application side of that
+wall (remote-access products that can show the login screen install a
+privileged Windows service to cross it).
+
+What happens instead: when the shared computer locks, viewers stay
+connected and see a clear *"The remote computer is locked"* notice over
+the last frame, and any input they send is ignored until the computer is
+unlocked. The working assumption is that you (or someone nearby) can get
+to the shared computer to sign it in; once its desktop is unlocked,
+streaming and control resume on their own. If that round trip is a
+nuisance, keep the shared computer signed in while you work on it
+remotely — for example by lengthening its lock/sleep timeout in Windows
+settings.
+
 ## How it works
 
 All of this is pure Python — the GUI is PySide6 (Qt), and the two places

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/src/remotedesktop/__init__.py

@@ -1,3 +1,3 @@
 """Remote desktop client/server for Windows computers on the same LAN."""
 
-__version__ = "1.6.0"
+__version__ = "1.8.0"

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/src/remotedesktop/app.py

@@ -55,6 +55,7 @@ from remotedesktop.preferences import (
     apply_theme,
     load_clipboard_sync_enabled,
     load_performance_window_seconds,
+    load_reduce_effects_enabled,
     load_theme,
     load_viewer_enabled,
 )
@@ -62,6 +63,7 @@ from remotedesktop.server import SharingTab, ViewersTable
 from remotedesktop.sharing import ShareClient
 from remotedesktop.single_instance import SingleInstance
 from remotedesktop.viewer import ViewerWidget
+from remotedesktop.visual_effects import VisualEffectsReducer
 
 _log = logging.getLogger("remotedesktop.app")
 
@@ -127,6 +129,7 @@ class MainWindow(QMainWindow):
         connect_port: int = DEFAULT_CONNECT_PORT,
         tray_available: bool | None = None,
         reconnect_base_seconds: float = 2.0,
+        effects_reducer: VisualEffectsReducer | None = None,
     ) -> None:
         super().__init__()
         self._reconnect_base = reconnect_base_seconds
@@ -164,6 +167,15 @@ class MainWindow(QMainWindow):
         self._tray: QSystemTrayIcon | None = None
         self._tray_notified = False
         self._quitting = False
+        # Windows visual effects are reduced only while someone is actually
+        # watching (fewer animation frames to encode and ship) and restored
+        # when the last viewer leaves. The default reducer changes real OS
+        # settings — tests always inject one with a fake backend.
+        self._effects_reducer = (
+            effects_reducer if effects_reducer is not None else VisualEffectsReducer()
+        )
+        self._reduce_effects = load_reduce_effects_enabled(self._settings)
+        self._sharing_viewer_count = 0
         self._fullscreen_state: dict | None = None
         self._fullscreen_hint: QLabel | None = None
 
@@ -180,6 +192,7 @@ class MainWindow(QMainWindow):
         self.sharing_tab.peerEvent.connect(self._record_server_peer)
         self.sharing_tab.sharingChanged.connect(self._on_sharing_changed)
         self.sharing_tab.viewerCountChanged.connect(self._update_sharing_indicator)
+        self.sharing_tab.viewerCountChanged.connect(self._on_viewer_count_changed)
 
         # One tab per server connection (inserted at the front, closable),
         # followed by the fixed tabs, which never get a close button. While
@@ -338,6 +351,7 @@ class MainWindow(QMainWindow):
         # three-state choice) and the viewer role's UI.
         self.preferences_tab.sharingModeChanged.connect(self.sharing_tab.set_mode)
         self.preferences_tab.viewerModeChanged.connect(self._set_viewer_enabled)
+        self.preferences_tab.reduceEffectsChanged.connect(self._on_reduce_effects_changed)
         self.preferences_tab.restart_button.clicked.connect(self._restart_app)
         self._tabs.addTab(self.preferences_tab, "Preferences")
         self._about_tab = AboutTab()
@@ -713,6 +727,27 @@ class MainWindow(QMainWindow):
         self._update_performance_tabs()
         self._update_connections_groups()
 
+    def _on_viewer_count_changed(self, count: int) -> None:
+        self._sharing_viewer_count = count
+        self._update_effects_reduction()
+
+    def _on_reduce_effects_changed(self, enabled: bool) -> None:
+        self._reduce_effects = enabled
+        self._update_effects_reduction()  # applies/restores live mid-session
+
+    def _update_effects_reduction(self) -> None:
+        """Reduce Windows visual effects while the preference is on AND a
+        viewer is connected; restore the user's values otherwise. Stop,
+        quit, and restart all reach here via their viewerCountChanged(0)."""
+        if self._reduce_effects and self._sharing_viewer_count > 0:
+            if self._effects_reducer.apply():
+                self.log(
+                    "Windows visual effects reduced while viewers are connected "
+                    "(restored when the last one disconnects)"
+                )
+        elif self._effects_reducer.restore():
+            self.log("Windows visual effects restored")
+
     def _quit(self) -> None:
         self._quitting = True
         self.close()
@@ -758,6 +793,9 @@ class MainWindow(QMainWindow):
             self._cancel_reconnect(session)
             session.client.close()
         self.sharing_tab.shutdown()
+        # shutdown's viewerCountChanged(0) already restored the effects;
+        # this is the safety net for any exit path that skipped the signal.
+        self._effects_reducer.restore()
         super().closeEvent(event)
         QApplication.quit()  # main() disables quit-on-last-window-closed
 
@@ -1002,6 +1040,7 @@ class MainWindow(QMainWindow):
         client.disconnected.connect(lambda s=session: self._on_disconnected(s))
         client.frameReceived.connect(lambda image, s=session: self._on_frame(s, image))
         client.cursorShapeChanged.connect(lambda shape, s=session: s.viewer.set_remote_cursor(shape))
+        client.sessionLockChanged.connect(lambda locked, s=session: s.viewer.set_session_locked(locked))
         client.logReceived.connect(lambda text, s=session: self._show_server_log(s.name, text))
         client.connectionFailed.connect(lambda _reason, s=session: self._schedule_reconnect(s))
         self._sessions.append(session)

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/src/remotedesktop/config.py

@@ -1,122 +1,138 @@
-"""Persistent per-machine state, all stored in the shared SQLite database.
-
-`Settings` is a generic key/value store (and holds this client's stable id and
-name). `PairedClients` maps each approved client id to the token issued at
-approval (server side). `KnownServers` records the servers this machine has
-paired with — pinned fingerprint and token — keyed by "host:port" (client
-side). All three operate on a `sqlite3.Connection` from `db.connect`.
-"""
-
-import socket
-import sqlite3
-import uuid
-from pathlib import Path
-
-import platformdirs
-
-
-def default_config_dir() -> Path:
-    return Path(platformdirs.user_data_dir("remotedesktop", appauthor=False))
-
-
-def default_db_path() -> Path:
-    return default_config_dir() / "remotedesktop.db"
-
-
-class Settings:
-    """A key/value store over the `settings` table."""
-
-    def __init__(self, connection: sqlite3.Connection) -> None:
-        self._db = connection
-
-    def get(self, key: str, default: str | None = None) -> str | None:
-        row = self._db.execute(
-            "SELECT value FROM settings WHERE key = ?", (key,)
-        ).fetchone()
-        return row[0] if row is not None else default
-
-    def set(self, key: str, value: str) -> None:
-        self._db.execute(
-            "INSERT INTO settings (key, value) VALUES (?, ?) "
-            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-            (key, value),
-        )
-        self._db.commit()
-
-
-def load_client_identity(connection: sqlite3.Connection) -> tuple[str, str]:
-    """Return this client's (stable id, display name), creating it on first use."""
-    settings = Settings(connection)
-    client_id = settings.get("client_id")
-    name = settings.get("client_name")
-    if client_id and name:
-        return client_id, name
-    client_id = str(uuid.uuid4())
-    name = socket.gethostname()
-    settings.set("client_id", client_id)
-    settings.set("client_name", name)
-    return client_id, name
-
-
-class PairedClients:
-    """Maps each approved client id to its shared token (server side).
-
-    A client is "approved" exactly when it has a token here.
-    """
-
-    def __init__(self, connection: sqlite3.Connection) -> None:
-        self._db = connection
-
-    def __contains__(self, client_id: str) -> bool:
-        return self.token_for(client_id) is not None
-
-    def token_for(self, client_id: str) -> str | None:
-        row = self._db.execute(
-            "SELECT token FROM paired_clients WHERE client_id = ?", (client_id,)
-        ).fetchone()
-        return row[0] if row is not None else None
-
-    def pair(self, client_id: str) -> str:
-        """Issue and persist a new token for a client, returning it."""
-        import secrets
-
-        token = secrets.token_hex(32)
-        self._db.execute(
-            "INSERT INTO paired_clients (client_id, token) VALUES (?, ?) "
-            "ON CONFLICT(client_id) DO UPDATE SET token = excluded.token",
-            (client_id, token),
-        )
-        self._db.commit()
-        return token
-
-    def revoke(self, client_id: str) -> None:
-        """Remove a client's token so it must be approved again to reconnect."""
-        self._db.execute("DELETE FROM paired_clients WHERE client_id = ?", (client_id,))
-        self._db.commit()
-
-
-class KnownServers:
-    """Client-side record of paired servers, keyed by "host:port"."""
-
-    def __init__(self, connection: sqlite3.Connection) -> None:
-        self._db = connection
-
-    def get(self, key: str) -> dict | None:
-        row = self._db.execute(
-            "SELECT fingerprint, token FROM known_servers WHERE key = ?", (key,)
-        ).fetchone()
-        return {"fingerprint": row[0], "token": row[1]} if row is not None else None
-
-    def remember(self, key: str, fingerprint: str, token: str) -> None:
-        self._db.execute(
-            "INSERT INTO known_servers (key, fingerprint, token) VALUES (?, ?, ?) "
-            "ON CONFLICT(key) DO UPDATE SET fingerprint = excluded.fingerprint, "
-            "token = excluded.token",
-            (key, fingerprint, token),
-        )
-        self._db.commit()
-
-    def forget(self, key: str) -> None:
-        """Drop a server's stored token and pin, so the next connection re-pairs."""
-        self._db.execute("DELETE FROM known_servers WHERE key = ?", (key,))
-        self._db.commit()
+"""Persistent per-machine state, all stored in the shared SQLite database.
+
+`Settings` is a generic key/value store (and holds this client's stable id and
+name). `PairedClients` maps each approved client id to the token issued at
+approval (server side). `KnownServers` records the servers this machine has
+paired with — pinned fingerprint and token — keyed by "host:port" (client
+side). All three operate on a `sqlite3.Connection` from `db.connect`.
+"""
+
+import socket
+import sqlite3
+import uuid
+from pathlib import Path
+
+import platformdirs
+from tobool import to_bool_strict
+
+
+def default_config_dir() -> Path:
+    return Path(platformdirs.user_data_dir("remotedesktop", appauthor=False))
+
+
+def default_db_path() -> Path:
+    return default_config_dir() / "remotedesktop.db"
+
+
+class Settings:
+    """A key/value store over the `settings` table."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        row = self._db.execute(
+            "SELECT value FROM settings WHERE key = ?", (key,)
+        ).fetchone()
+        return row[0] if row is not None else default
+
+    def set(self, key: str, value: str) -> None:
+        self._db.execute(
+            "INSERT INTO settings (key, value) VALUES (?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+            (key, value),
+        )
+        self._db.commit()
+
+    def get_bool(self, key: str, default: bool = False) -> bool:
+        """A boolean setting, stored as "1"/"0" (the historical on-disk
+        form). Anything unparseable falls back to the default — settings
+        are data, and junk must never take the app down."""
+        value = self.get(key)
+        if value is None:
+            return default
+        try:
+            return to_bool_strict(value)
+        except ValueError:
+            return default
+
+    def set_bool(self, key: str, value: bool) -> None:
+        self.set(key, "1" if value else "0")
+
+
+def load_client_identity(connection: sqlite3.Connection) -> tuple[str, str]:
+    """Return this client's (stable id, display name), creating it on first use."""
+    settings = Settings(connection)
+    client_id = settings.get("client_id")
+    name = settings.get("client_name")
+    if client_id and name:
+        return client_id, name
+    client_id = str(uuid.uuid4())
+    name = socket.gethostname()
+    settings.set("client_id", client_id)
+    settings.set("client_name", name)
+    return client_id, name
+
+
+class PairedClients:
+    """Maps each approved client id to its shared token (server side).
+
+    A client is "approved" exactly when it has a token here.
+    """
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def __contains__(self, client_id: str) -> bool:
+        return self.token_for(client_id) is not None
+
+    def token_for(self, client_id: str) -> str | None:
+        row = self._db.execute(
+            "SELECT token FROM paired_clients WHERE client_id = ?", (client_id,)
+        ).fetchone()
+        return row[0] if row is not None else None
+
+    def pair(self, client_id: str) -> str:
+        """Issue and persist a new token for a client, returning it."""
+        import secrets
+
+        token = secrets.token_hex(32)
+        self._db.execute(
+            "INSERT INTO paired_clients (client_id, token) VALUES (?, ?) "
+            "ON CONFLICT(client_id) DO UPDATE SET token = excluded.token",
+            (client_id, token),
+        )
+        self._db.commit()
+        return token
+
+    def revoke(self, client_id: str) -> None:
+        """Remove a client's token so it must be approved again to reconnect."""
+        self._db.execute("DELETE FROM paired_clients WHERE client_id = ?", (client_id,))
+        self._db.commit()
+
+
+class KnownServers:
+    """Client-side record of paired servers, keyed by "host:port"."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def get(self, key: str) -> dict | None:
+        row = self._db.execute(
+            "SELECT fingerprint, token FROM known_servers WHERE key = ?", (key,)
+        ).fetchone()
+        return {"fingerprint": row[0], "token": row[1]} if row is not None else None
+
+    def remember(self, key: str, fingerprint: str, token: str) -> None:
+        self._db.execute(
+            "INSERT INTO known_servers (key, fingerprint, token) VALUES (?, ?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET fingerprint = excluded.fingerprint, "
+            "token = excluded.token",
+            (key, fingerprint, token),
+        )
+        self._db.commit()
+
+    def forget(self, key: str) -> None:
+        """Drop a server's stored token and pin, so the next connection re-pairs."""
+        self._db.execute("DELETE FROM known_servers WHERE key = ?", (key,))
+        self._db.commit()

{remotedesktop-1.6.0 → remotedesktop-1.8.0}/src/remotedesktop/preferences.py

@@ -36,6 +36,7 @@ from remotedesktop.server import (
 PERFORMANCE_WINDOW_KEY = "performance_window_seconds"
 DEFAULT_PERFORMANCE_WINDOW_SECONDS = 120
 CLIPBOARD_SYNC_KEY = "clipboard_sync_enabled"
+REDUCE_EFFECTS_KEY = "reduce_effects_enabled"
 VIEWER_KEY = "viewer_enabled"
 THEME_KEY = "theme"
 THEME_SYSTEM = "system"  # follow the OS light/dark setting
@@ -45,7 +46,13 @@ _THEMES = (THEME_SYSTEM, THEME_LIGHT, THEME_DARK)
 
 
 def load_clipboard_sync_enabled(settings: Settings) -> bool:
-    return settings.get(CLIPBOARD_SYNC_KEY, "1") != "0"
+    return settings.get_bool(CLIPBOARD_SYNC_KEY, True)
+
+
+def load_reduce_effects_enabled(settings: Settings) -> bool:
+    # Default on (per the user's request): the effects come back the moment
+    # the last viewer disconnects, and nothing is persisted OS-side.
+    return settings.get_bool(REDUCE_EFFECTS_KEY, True)
 
 
 def load_theme(settings: Settings) -> str:
@@ -69,7 +76,7 @@ def apply_theme(theme: str) -> None:
 
 
 def load_viewer_enabled(settings: Settings) -> bool:
-    return settings.get(VIEWER_KEY, "1") != "0"
+    return settings.get_bool(VIEWER_KEY, True)
 
 
 def load_performance_window_seconds(settings: Settings) -> int:
@@ -89,6 +96,9 @@ class PreferencesTab(QWidget):
     # The viewer (client) role: whether this instance connects to other
     # computers at all. The window shows/hides the client UI accordingly.
     viewerModeChanged = Signal(bool)
+    # Reduce Windows visual effects while viewers are connected; the window
+    # owns the VisualEffectsReducer and applies/restores on this.
+    reduceEffectsChanged = Signal(bool)
 
     def __init__(
         self,
@@ -121,6 +131,20 @@ class PreferencesTab(QWidget):
         self.clipboard_checkbox = QCheckBox("Sync clipboard with connected computers")
         self.clipboard_checkbox.setChecked(load_clipboard_sync_enabled(settings))
         self.clipboard_checkbox.toggled.connect(self._on_clipboard_toggled)
+        self.reduce_effects_checkbox = QCheckBox(
+            "Reduce Windows visual effects while sharing this screen"
+        )
+        self.reduce_effects_checkbox.setToolTip(
+            "Makes the remote view feel more responsive: window animations, "
+            "menu fades, and shadows each stream as a burst of screen "
+            "updates, so turning them off while viewers are connected lets "
+            "the remote screen snap instead of smearing — and saves "
+            "bandwidth. Submenus also open faster. Your Windows settings "
+            "come back when the last viewer disconnects; nothing is "
+            "permanently changed."
+        )
+        self.reduce_effects_checkbox.setChecked(load_reduce_effects_enabled(settings))
+        self.reduce_effects_checkbox.toggled.connect(self._on_reduce_effects_toggled)
         # The three-state sharing choice: off, view-only, or full control.
         self.sharing_off_radio = QRadioButton(
             "Not shared — no one can see this computer's screen"
@@ -185,6 +209,7 @@ class PreferencesTab(QWidget):
         layout.addRow("Theme", theme_box)
         layout.addRow("Performance history", self.history_minutes)
         layout.addRow(self.clipboard_checkbox)
+        layout.addRow(self.reduce_effects_checkbox)
         layout.addRow(self.autostart_checkbox)
         layout.addRow(self.restart_button)
 
@@ -203,7 +228,7 @@ class PreferencesTab(QWidget):
         )
 
     def _on_viewer_toggled(self, checked: bool) -> None:
-        self._settings.set(VIEWER_KEY, "1" if checked else "0")
+        self._settings.set_bool(VIEWER_KEY, checked)
         self.statusMessage.emit(
             "Client (viewer) role enabled — this computer can connect to servers"
             if checked
@@ -222,8 +247,17 @@ class PreferencesTab(QWidget):
             }[theme]
         )
 
+    def _on_reduce_effects_toggled(self, checked: bool) -> None:
+        self._settings.set_bool(REDUCE_EFFECTS_KEY, checked)
+        self.statusMessage.emit(
+            "Windows visual effects will be reduced while viewers are connected"
+            if checked
+            else "Windows visual effects will be left unchanged while sharing"
+        )
+        self.reduceEffectsChanged.emit(checked)
+
     def _on_clipboard_toggled(self, checked: bool) -> None:
-        self._settings.set(CLIPBOARD_SYNC_KEY, "1" if checked else "0")
+        self._settings.set_bool(CLIPBOARD_SYNC_KEY, checked)
         if self._clipboard is not None:
             self._clipboard.enabled = checked
         self.statusMessage.emit(